1.png2.png3.png4.png5.png6.png7.png

wait 加锁示例

  1. public class WaitDemo {
  2.     private static Object locker = new Object();
  4.     public static void main(String[] args) throws InterruptedException {
  5.         WaitDemo waitDemo = new WaitDemo();
  7.         // 启动新线程，防止主线程被休眠
  8.         new Thread(() -> {
  9.             try {
  10.                 waitDemo.doWait();
  11.             } catch (InterruptedException e) {
  12.                 e.printStackTrace();
  13.             }
  14.         }).start();
  15.         Thread.sleep(200); // 此行本身没有意义，是为了确保 wait() 先执行再执行 notify()
  16.         waitDemo.doNotify();
  17.     }
  19.     /**
  20.     * 执行 wait()
  21.     */
  22.     private void doWait() throws InterruptedException {
  23.         synchronized (locker) {
  24.             System.out.println("wait start.");
  25.             locker.wait();
  26.             System.out.println("wait end.");
  27.         }
  28.     }
  30.     /**
  31.     * 执行 notify()
  32.     */
  33.     private void doNotify() {
  34.         synchronized (locker) {
  35.             System.out.println("notify start.");
  36.             locker.notify();
  37.             System.out.println("notify end.");
  38.         }
  39.     }
  40. }

以上程序的执行结果为：
wait start.
notify start.
notify end.
wait end.

代码解析

从上述代码可以看出，我们给 wait() 和 notify() 两个方法上了同一把锁（locker），但在调用完 wait() 方法之后 locker 锁就被释放了，所以程序才能正常执行 notify() 的代码，因为是同一把锁，如果不释放锁的话，是不会执行 notify() 的代码的，这一点也可以从打印的结果中证实（结果输出顺序），所以综合以上情况来说 wait() 方法是释放锁的。

sleep 加锁示例

  1. public class WaitDemo {
  2.     private static Object locker = new Object();
  4.     public static void main(String[] args) throws InterruptedException {
  5.         WaitDemo waitDemo = new WaitDemo();
  6.         // 启动新线程，防止主线程被休眠
  7.         new Thread(() -> {
  8.             synchronized (locker) {
  9.                 try {
  10.                     System.out.println("sleep start.");
  11.                     Thread.sleep(1000);
  12.                     System.out.println("sleep end.");
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 }
  16.             }
  17.         }).start();
  19.         Thread.sleep(200);
  20.         waitDemo.doNotify();
  21.     }
  23.     /**
  24.      * 执行 notify()
  25.      */
  26.     private void doNotify() {
  27.         synchronized (locker) {
  28.             System.out.println("notify start.");
  29.             locker.notify();
  30.             System.out.println("notify end.");
  31.         }
  32.     }
  33. }

以上程序的执行结果为：
sleep start.
sleep end.
notify start.
notify end.

代码解析

从上述代码可以看出 sleep(1000) 方法（行号：11）执行之后，调用 notify() 方法并没有获取到 locker 锁，从上述执行结果中可以看出，而是执行完 sleep(1000) 方法之后才执行的 notify() 方法，因此可以证明调用 sleep() 方法并不会释放锁。

知识扩展

1.sleep 和 wait 有什么区别？

sleep 和 wait 几乎是所有面试中必问的题，但想完全回答正确似乎没那么简单。
对于 sleep 和 wait 的区别，通常的回答是这样的：

  • wait 必须搭配 synchronize 一起使用，而 sleep 不需要；
  • 进入 wait 状态的线程能够被 notify 和 notifyAll 线程唤醒，而 sleep 状态的线程不能被 notify 方法唤醒；
  • wait 通常有条件地执行，线程会一直处于 wait 状态，直到某个条件变为真，但是 sleep 仅仅让你的线程进入睡眠状态；
  • wait 方法会释放对象锁，但 sleep 方法不会。

但上面的回答显然遗漏了一个重要的区别，在调用 wait 方法之后，线程会变为 WATING 状态，而调用 sleep 方法之后，线程会变为 TIMED_WAITING 状态。

2.wait 能不能在 static 方法中使用？为什么？

不能，因为 wait 方法是实例方法（非 static 方法），因此不能在 static 中使用，源码如下：
public final void wait() throws InterruptedException { wait(0); }

3.wait/notify 可以不搭配 synchronized 使用吗？为什么？

不行，因为不搭配 synchronized 使用的话程序会报错，如下图所示：
image.png
更深层次的原因是因为不加 synchronized 的话会造成 Lost Wake-Up Problem，唤醒丢失的问题，详情可见：https://juejin.im/post/5e6a4d8a6fb9a07cd80f36d1

总结

本文我们通过 synchronized 锁定同一对象，来测试 wait 和 sleep 方法，再通过执行结果的先后顺序证明：wait 方法会释放锁，而 sleep 方法并不会。同时我们还讲了几个 wait 和 sleep 的常见面试问题，希望本文可以帮助到你。