Java中wait()和sleep()的区别

原创于 2024-11-24 09:15:00 发布 · 1.1k 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#java #python #开发语言

Java中wait()和sleep()的区别

引言

在Java多线程编程中，wait() 和 sleep() 是两个常用的方法，用于控制线程的执行状态。虽然它们都可以使线程暂停执行，但它们的作用和使用场景有很大的不同。本文将深入探讨 wait() 和 sleep() 的区别，包括它们的定义、调用方式、适用场景以及实际应用。

前置知识

在深入学习 wait() 和 sleep() 之前，你需要了解以下基础知识：

Java基础：熟悉Java的基本语法、类和对象的概念。
多线程编程：理解Java中的线程、线程同步和线程通信的基本概念。
同步机制：了解Java中的同步机制，如 synchronized 关键字和 Object 类的同步方法。

wait() 方法

wait() 方法是 Object 类的一个方法，用于使当前线程进入等待状态，直到其他线程调用 notify() 或 notifyAll() 方法唤醒它。wait() 方法必须在同步块（synchronized 块）中调用，否则会抛出 IllegalMonitorStateException 异常。

wait() 方法的特点：

必须在同步块中调用。
使当前线程进入等待状态，并释放对象的锁。
可以通过 notify() 或 notifyAll() 方法唤醒。
适用于线程间的协作和通信。

示例代码：wait() 方法

public class WaitExample {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 is waiting...");
                    lock.wait();
                    System.out.println("Thread 1 is resumed.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 is notifying...");
                lock.notify();
            }
        });

        thread1.start();
        thread2.start();
    }
}

代码解释：

lock 是一个对象锁，用于同步块。
thread1 调用 lock.wait() 进入等待状态，并释放 lock 的锁。
thread2 调用 lock.notify() 唤醒 thread1。
thread1 被唤醒后继续执行。

sleep() 方法

sleep() 方法是 Thread 类的一个静态方法，用于使当前线程暂停执行指定的时间（以毫秒为单位）。sleep() 方法不会释放对象的锁，因此其他线程无法在 sleep() 期间获取该锁。

sleep() 方法的特点：

可以在任何地方调用。
使当前线程暂停执行指定的时间，但不释放对象的锁。
适用于需要暂停线程执行一段时间的场景。

示例代码：sleep() 方法

public class SleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Thread is sleeping...");
                Thread.sleep(2000); // 暂停2秒
                System.out.println("Thread is resumed.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread.start();
    }
}

代码解释：

thread 调用 Thread.sleep(2000) 暂停执行 2 秒。
2 秒后，thread 继续执行。

wait() 和 sleep() 的区别

特性	wait()	sleep()
所属类	`Object` 类	`Thread` 类
调用方式	必须在同步块中调用	可以在任何地方调用
锁的释放	释放对象的锁	不释放对象的锁
唤醒方式	通过 `notify()` 或 `notifyAll()` 方法唤醒	时间到期自动唤醒
适用场景	线程间的协作和通信	需要暂停线程执行一段时间

wait() 和 sleep() 的实际应用

wait() 的应用场景

线程间的协作：例如，生产者-消费者模式中，生产者线程在缓冲区满时调用 wait() 方法等待，消费者线程在缓冲区空时调用 wait() 方法等待。
线程同步：例如，多个线程需要等待某个条件满足后再继续执行。

示例代码：生产者-消费者模式

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumerExample {
    private static final int CAPACITY = 5;
    private static final Queue<Integer> buffer = new LinkedList<>();

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            int value = 0;
            while (true) {
                synchronized (buffer) {
                    while (buffer.size() == CAPACITY) {
                        try {
                            System.out.println("Buffer is full, producer is waiting...");
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("Producing value: " + value);
                    buffer.add(value++);
                    buffer.notify();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            while (true) {
                synchronized (buffer) {
                    while (buffer.isEmpty()) {
                        try {
                            System.out.println("Buffer is empty, consumer is waiting...");
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int value = buffer.poll();
                    System.out.println("Consuming value: " + value);
                    buffer.notify();
                }
            }
        });

        producer.start();
        consumer.start();
    }
}

代码解释：

buffer 是一个共享的缓冲区，用于存储生产者生产的数据。
生产者线程在缓冲区满时调用 buffer.wait() 方法等待。
消费者线程在缓冲区空时调用 buffer.wait() 方法等待。
生产者线程生产数据后调用 buffer.notify() 方法唤醒消费者线程。
消费者线程消费数据后调用 buffer.notify() 方法唤醒生产者线程。

sleep() 的应用场景

定时任务：例如，需要每隔一段时间执行一次任务。
模拟延迟：例如，模拟网络延迟或用户操作延迟。

示例代码：定时任务

public class TimerTaskExample {
    public static void main(String[] args) {
        Thread timerTask = new Thread(() -> {
            while (true) {
                try {
                    System.out.println("Executing timer task...");
                    Thread.sleep(5000); // 每隔5秒执行一次任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        timerTask.start();
    }
}

代码解释：

timerTask 线程每隔 5 秒执行一次任务。
Thread.sleep(5000) 使线程暂停 5 秒。

总结

Java中的 wait() 和 sleep() 是两个常用的方法，用于控制线程的执行状态。wait() 方法用于线程间的协作和通信，必须在同步块中调用，并释放对象的锁；sleep() 方法用于暂停线程执行一段时间，可以在任何地方调用，但不释放对象的锁。通过本文的学习，你应该能够更好地理解这两种方法的区别及其使用场景，并能够在实际编程中应用这些知识。