请说说 sleep 和 wait 的区别？

请说说 sleep 和 wait 的区别？#

答：sleep() 和 wait() 是 Java 中用于暂停当前线程的两个重要方法，sleep 是让当前线程休眠，不涉及对象类，也不需要获取对象的锁，属于 Thread 类的方法；wait 是让获得对象锁的线程实现等待，前提要获得对象的锁，属于 Object 类的方法。它们之间的区别主要有以下几点：

所属类不同#

sleep() 方法专属于 Thread 类。
wait() 方法专属于 Object 类。

锁行为不同#

当线程执行 sleep 方法时，它不会释放任何锁。也就是说，如果一个线程在持有某个对象的锁时调用了 sleep，它在睡眠期间仍然会持有这个锁。

1
class SleepDoesNotReleaseLock {
2

3
    private static final Object lock = new Object();
4

5
    public static void main(String[] args) throws InterruptedException {
6
        Thread sleepingThread = new Thread(() -> {
7
            synchronized (lock) {
8
                System.out.println("Thread 1 会继续持有锁，并且进入睡眠状态");
9
                try {
10
                    Thread.sleep(5000);
11
                } catch (InterruptedException e) {
12
                    e.printStackTrace();
13
                }
14
                System.out.println("Thread 1 醒来了，并且释放了锁");
15
            }
16
        });
17

18
        Thread waitingThread = new Thread(() -> {
19
            synchronized (lock) {
20
                System.out.println("Thread 2 进入同步代码块");
21
            }
22
        });
23

24
        sleepingThread.start();
25
        Thread.sleep(1000);
26
        waitingThread.start();
27
    }
28
}

输出结果：

1
Thread 1 会继续持有锁，并且进入睡眠状态
2
Thread 1 醒来了，并且释放了锁
3
Thread 2 进入同步代码块

从输出中我们可以看到，waitingThread 必须等待 sleepingThread 完成睡眠后才能进入同步代码块。而当线程执行 wait 方法时，它会释放它持有的那个对象的锁，这使得其他线程可以有机会获取该对象的锁。

1
class WaitReleasesLock {
2

3
    private static final Object lock = new Object();
4

5
    public static void main(String[] args) throws InterruptedException {
6
        Thread waitingThread = new Thread(() -> {
7
            synchronized (lock) {
8
                try {
9
                    System.out.println("Thread 1 持有锁，准备等待 5 秒");
10
                    lock.wait(5000);
11
                    System.out.println("Thread 1 醒来了，并且退出同步代码块");
12
                } catch (InterruptedException e) {
13
                    e.printStackTrace();
14
                }
15
            }
16
        });
17

18
        Thread notifyingThread = new Thread(() -> {
19
            synchronized (lock) {
20
                System.out.println("Thread 2 尝试唤醒等待中的线程");
21
                lock.notify();
22
                System.out.println("Thread 2 执行完了 notify");
23
            }
24
        });
25

26
        waitingThread.start();
27
        Thread.sleep(1000);
28
        notifyingThread.start();
29
    }
30
}

输出结果：

1
Thread 1 持有锁，准备等待 5 秒
2
Thread 2 尝试唤醒等待中的线程
3
Thread 2 执行完了 notify
4
Thread 1 醒来了，并且退出同步代码块

这表明 waitingThread 在调用 wait 后确实释放了锁。

使用条件不同#

sleep() 方法可以在任何地方被调用。
wait() 方法必须在同步代码块或同步方法中被调用，这是因为调用 wait() 方法的前提是当前线程必须持有对象的锁。否则会抛出 IllegalMonitorStateException 异常。

唤醒方式不同#

sleep() 方法在指定的时间过后，线程会自动唤醒继续执行。
wait() 方法需要依靠 notify()、notifyAll() 方法或者 wait() 方法中指定的等待时间到期来唤醒线程。

抛出异常不同#

sleep() 方法在等待期间，如果线程被中断，会抛出 InterruptedException。
如果线程被中断或等待时间到期时，wait() 方法同样会在等待期间抛出 InterruptedException。

我们来通过代码再感受一下 sleep() 和 wait() 在用法上的区别，先看 sleep() 的用法：

1
class SleepExample {
2
    public static void main(String[] args) {
3
        Thread thread = new Thread(() -> {
4
            System.out.println("线程准备休眠 2 秒");
5
            try {
6
                Thread.sleep(2000); // 线程将睡眠2秒
7
            } catch (InterruptedException e) {
8
                e.printStackTrace();
9
            }
10
            System.out.println("线程醒来了");
11
        });
12

13
        thread.start();
14
    }
15
}

再来看 wait() 的用法：

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

5
        Thread thread = new Thread(() -> {
6
            synchronized (lock) {
7
                try {
8
                    System.out.println("线程准备等待 2 秒");
9
                    lock.wait(2000); // 线程会等待2秒，或者直到其他线程调用 lock.notify()/notifyAll()
10
                    System.out.println("线程结束等待");
11
                } catch (InterruptedException e) {
12
                    e.printStackTrace();
13
                }
14
            }
15
        });
16

17
        thread.start();
18
    }
19
}