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

引言

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

前置知识

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

1. Java基础：熟悉Java的基本语法、类和对象的概念。
2. 多线程编程：理解Java中的线程、线程同步和线程通信的基本概念。
3. 同步机制：了解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() 的应用场景

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

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

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() 的应用场景

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

示例代码：定时任务

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() 方法用于暂停线程执行一段时间，可以在任何地方调用，但不释放对象的锁。通过本文的学习，你应该能够更好地理解这两种方法的区别及其使用场景，并能够在实际编程中应用这些知识。

进一步学习

如果你希望深入学习Java的 wait() 和 sleep() 方法，可以参考以下资源：

1. Java官方文档：Object.wait() 和 Thread.sleep()
2. 书籍：《Java并发编程实战》
3. 在线教程：Java Threads

希望本文对你有所帮助，祝你在Java编程的道路上越走越远！