天猫2面： Wait 和 Sleep 有什么区别？

发表于 2025-03-31 更新于 2025-03-29 分类于 Java 阅读次数：本文字数： 3.1k 阅读时长 ≈ 3 分钟

大家好呀，我是猿java。

作为一名 Java 开发者，尤其是涉及到多线程的部分，wait 和 sleep 是两个经常会碰到的方法。虽然它们看起来功能相似，但实际上有着显著的区别。这篇文章，我们将深入探讨两者的不同之处，并理解它们背后的原理。

1. `wait` 与 `sleep` 的基本区别

首先，让我们来看看 wait 和 sleep 的几个主要区别：

1. 所属类不同

wait()：是 java.lang.Object 类的方法。这意味着每一个对象都能调用 wait() 方法。
sleep()：是 java.lang.Thread 类的静态方法。它属于线程类本身，不依赖于具体的对象。

2. 锁的持有情况

wait()：只能在同步方法或同步代码块中调用，必须持有对象的锁。调用 wait() 后，线程会释放锁。
sleep()：可以在任何地方调用，不需要持有任何锁。调用 sleep() 时，线程不会释放它持有的锁。

3. 主要用途

wait()：主要用于线程之间的通信和协调，通常与 notify() 或 notifyAll() 一起使用，实现生产者-消费者模式等。
sleep()：主要用于让线程暂停执行一段时间，通常用于控制执行速度或实现延时操作。

4. 锁的释放

wait()：调用后会释放对象的监视器锁，让其他等待该锁的线程有机会执行。
sleep()：调用后不会释放任何锁，线程在睡眠期间仍然持有所有已经获取的锁。

2. 原理分析

理解 wait 和 sleep 的原理，有助于更好地掌握它们的使用场景。

2.1 `wait()` 的原理

wait() 方法使当前线程进入等待状态，直到被其他线程通过 notify() 或 notifyAll() 唤醒，或者等待时间超过指定的超时时间。调用 wait() 前，线程必须持有对象的监视器锁。调用后，线程会释放该锁，允许其他线程进入同步块或方法执行。当被唤醒后，线程会重新竞争锁，有机会继续执行。

这种机制主要用于线程间的协作。例如，生产者线程生产数据后通过 notify() 唤醒消费者线程进行消费。

2.2 `sleep()` 的原理

sleep() 方法让当前线程暂停执行指定的时间，但线程在此期间不会释放任何锁。调用 sleep() 后，线程进入休眠状态，时间到达后自动恢复运行。这种方式主要用于控制线程的执行节奏，比如定时任务或模拟延时操作。

sleep() 不依赖于同步机制，因此更加灵活，但也不适合用于线程间的协作。

3. 实例演示

让我们通过两个简单的示例，看看 wait() 和 sleep() 在实际中的使用区别。

3.1 使用 `wait()`

假设我们有一个共享资源，生产者线程负责生成数据，消费者线程负责消费数据。我们希望在没有数据时，消费者线程等待；有数据时，消费者被唤醒并消费数据。

public class ProducerConsumer {
    private final Object lock = new Object();
    private boolean hasData = false;

    public void produce() throws InterruptedException {
        synchronized (lock) {
            while (hasData) {
                lock.wait(); // 等待消费者消费数据
            }
            System.out.println("生产数据...");
            hasData = true;
            lock.notify(); // 唤醒消费者
        }
    }

    public void consume() throws InterruptedException {
        synchronized (lock) {
            while (!hasData) {
                lock.wait(); // 等待生产者生产数据
            }
            System.out.println("消费数据...");
            hasData = false;
            lock.notify(); // 唤醒生产者
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        // 生产者线程
        new Thread(() -> {
            try {
                while (true) {
                    pc.produce();
                    Thread.sleep(1000); // 模拟生产时间
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Producer").start();

        // 消费者线程
        new Thread(() -> {
            try {
                while (true) {
                    pc.consume();
                    Thread.sleep(1500); // 模拟消费时间
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Consumer").start();
    }
}

在这个例子中，produce() 和 consume() 方法都在同步块中调用 wait() 和 notify()，实现了生产者和消费者之间的协调。当生产者生产完数据后，通过 notify() 唤醒等待的消费者；消费者消费完数据后，唤醒生产者继续生产。

3.2 使用 `sleep()`

现在，我们来看一个简单的使用 sleep() 的例子，来模拟延时操作。

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("任务开始执行...");
        try {
            Thread.sleep(2000); // 暂停2秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("任务执行完毕！");
    }
}

运行这个程序，你会发现”任务开始执行…”输出后，程序暂停了2秒，然后输出”任务执行完毕！”。这里，sleep() 简单地让线程暂停了一段时间，而不涉及任何同步或线程间通信。

4.总结

本文，我们分析了 wait() 和 sleep() 的区别，通过今天的分享，我们了解了 wait() 和 sleep() 在 Java 中的区别和各自的使用场景：

wait() 是用于线程间的协调与通信，必须在同步环境下使用，并且会释放锁。
sleep() 用于让线程暂停执行一段时间，不涉及锁的释放，适用于延时操作。

掌握这两个方法的区别和用法，能够帮助我们更有效地管理多线程环境下的线程行为，提高程序的并发性能和稳定性。

希望这篇文章对你有所帮助！如果你在项目中遇到过 wait() 和 sleep() 的问题，欢迎在评论区分享你的经验和见解！

5. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

1. wait 与 sleep 的基本区别

2. 原理分析

2.1 wait() 的原理

2.2 sleep() 的原理