Java 中 sleep 与 wait 方法的区别解析 ?
在 Java 多线程编程中，sleep 和 wait 是两个常用的线程控制方法。尽管它们都用于让线程暂停执行，但在使用场景和行为上存在显著差异。深入理解这两者的区别，有助于编写更高效、可靠的并发程序。本文将详细解析 sleep 与 wait 的区别，并通过示例代码进行说明。
? 基本概念

sleep 方法:

属于 Thread 类 的静态方法。
用于让当前线程暂停执行指定的时间，时间结束后线程自动恢复运行。
在 sleep 期间，线程不会释放其持有的锁。


wait 方法:

属于 Object 类 的实例方法。
使当前线程进入等待状态，直到被其他线程调用 notify 或 notifyAll 方法唤醒。
在 wait 期间，线程会释放其持有的锁。



? 详细对比



特性
sleep?
wait?




所属类
Thread类的静态方法
Object类的实例方法


调用方式
Thread.sleep(milliseconds);
object.wait();


锁释放
不会释放持有的锁
会释放持有的锁


使用场景
需要暂停线程执行一段时间
线程间协作，需要等待某个条件满足


唤醒机制
自动在指定时间后唤醒
需其他线程调用 notify或 notifyAll来唤醒


依赖条件
无需在同步块或方法中调用
必须在同步块或同步方法中调用


异常处理
InterruptedException
InterruptedException和 IllegalMonitorStateException


继承关系
属于 Thread类，无法被重写
属于 Object类，可以被重写



?️ 使用示例与详解
使用 sleep 方法
public class SleepExample {
    public static void main(String[] args) {
        System.out.println("线程开始执行");
        try {
            // 线程暂停执行2秒
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println("线程被中断");
        }
        System.out.println("线程继续执行");
    }
}
​
解释:

Thread.sleep(2000);: 当前线程暂停执行** 2000 毫秒（2秒）**。
锁行为: 即使在持有锁的情况下调用 sleep，锁仍然被保持，不会释放。
自动唤醒: 线程在指定时间后自动恢复执行，无需其他线程干预。

使用 wait 方法
public class WaitExample {
    private static final Object LOCK = new Object();

    public static void main(String[] args) {
        Thread waitingThread = new Thread(() -> {
            synchronized (LOCK) {
                try {
                    System.out.println("线程进入等待状态");
                    LOCK.wait(); // 释放锁，进入等待
                    System.out.println("线程被唤醒");
                } catch (InterruptedException e) {
                    System.out.println("线程被中断");
                }
            }
        });

        Thread notifyingThread = new Thread(() -> {
            synchronized (LOCK) {
                System.out.println("唤醒线程准备唤醒等待线程");
                LOCK.notify(); // 唤醒等待中的线程
                System.out.println("唤醒线程已调用 notify");
            }
        });

        waitingThread.start();
        try {
            // 确保等待线程先进入等待状态
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        notifyingThread.start();
    }
}
​
解释:

同步块 synchronized (LOCK): 确保对 LOCK 对象的独占访问。
LOCK.wait();:

当前线程释放 LOCK 对象的锁。
进入等待状态，直到被其他线程唤醒。


LOCK.notify();:

唤醒在 LOCK 对象上等待的一个线程。
唤醒后，等待线程需重新竞争 LOCK 对象的锁，才能继续执行。


锁释放与获取:

wait 方法释放锁，允许其他线程进入同步块。
唤醒后，等待线程重新获取锁才能继续执行。



? 关键区别解析

所属类与调用方式:

sleep 是 Thread 类的静态方法，可以直接通过 Thread.sleep() 调用。
wait 是 Object 类的实例方法，需要在具体的对象实例上调用，如 obj.wait()。


锁的释放:

sleep: 在暂停期间，线程持有的所有锁不会被释放。这意味着其他线程无法访问被锁定的资源，直到 sleep 完成。
wait: 在进入等待状态时，线程会自动释放其持有的锁，允许其他线程获取锁并执行相应的同步操作。


唤醒机制:

sleep: 不依赖于其他线程的操作，线程在指定时间后自动恢复执行。
wait: 需要其他线程显式调用 notify