Java
在多线程编程中,wait 方法是让当前线程进入休眠状态,直到另一个线程调用了 notify 或 notifyAll 方法之后,才能继续恢复执行。而在 Java 中,wait 和 notify/notifyAll 有着一套自己的使用格式要求,也就是在使用 wait 和 notify(notifyAll 的使用和 notify 类似,所以下文就只用 notify 用来指代二者)必须配合 synchronized 一起使用才行。

wait/notify基础使用

wait 和 notify 的基础方法如下:

  1. Object lock = new Object();
  2. new Thread(() -> {
  3. synchronized (lock) {
  4. try {
  5. System.out.println("wait 之前");
  6. // 调用 wait 方法
  7. lock.wait();
  8. System.out.println("wait 之后");
  9. } catch (InterruptedException e) {
  10. e.printStackTrace();
  11. }
  12. }
  13. }).start();
  14. Thread.sleep(100);
  15. synchronized (lock) {
  16. System.out.println("执行 notify");
  17. // 调用 notify 方法
  18. lock.notify();
  19. }

以上代码的执行结果如下图所示:为什么wait和notify必须放在synchronized中? - 图1

wait/notify和synchronized一起用?

那问题来了,是不是 wait 和 notify 一定要配合 synchronized 一起使用呢?wait 和 notify 单独使用行不行呢?尝试将以上代码中的 synchronized 代码行删除,实现代码如下:为什么wait和notify必须放在synchronized中? - 图2初看代码好像没啥问题,编译器也没报错,好像能“正常使用”,然而当运行以上程序时就会发生如下错误:为什么wait和notify必须放在synchronized中? - 图3从上述结果可以看出:无论是 wait 还是 notify,如果不配合 synchronized 一起使用,在程序运行时就会报 IllegalMonitorStateException 非法的监视器状态异常,而且 notify 也不能实现程序的唤醒功能了。

原因分析

从上述的报错信息可以看出,JVM 在运行时会强制检查 wait 和 notify 有没有在 synchronized 代码中,如果没有的话就会报非法监视器状态异常(IllegalMonitorStateException),但这也仅仅是运行时的程序表象,那为什么 Java 要这样设计呢?其实这样设计的原因就是为了防止多线程并发运行时,程序的执行混乱问题。初看这句话,好像是用来描述“锁”的。然而实际情况也是如此,wait 和 notify 引入锁就是来规避并发执行时程序的执行混乱问题的。那这个“执行混乱问题”到底是啥呢?接下来继续往下看。

wait和notify问题复现

假设 wait 和 notify 可以不加锁,用它们来实现一个自定义阻塞队列。这里的阻塞队列是指读操作阻塞,也就是当读取数据时,如果有数据就返回数据,如果没有数据则阻塞等待数据,实现代码如下:

  1. class MyBlockingQueue {
  2. // 用来保存数据的集合
  3. Queue<String> queue = new LinkedList<>();
  4. /**
  5. * 添加方法
  6. */
  7. public void put(String data) {
  8. // 队列加入数据
  9. queue.add(data);
  10. // 唤醒线程继续执行(这里的线程指的是执行 take 方法的线程)
  11. notify(); // ③
  12. }
  13. /**
  14. * 获取方法(阻塞式执行)
  15. * 如果队列里面有数据则返回数据,如果没有数据就阻塞等待数据
  16. * @return
  17. */
  18. public String take() throws InterruptedException {
  19. // 使用 while 判断是否有数据(这里使用 while 而非 if 是为了防止虚假唤醒)
  20. while (queue.isEmpty()) { // ①
  21. // 没有任务,先阻塞等待
  22. wait(); // ②
  23. }
  24. return queue.remove(); // 返回数据
  25. }
  26. }

注意上述代码,在代码中标识了三个关键执行步骤:
①:判断队列中是否有数据;
②:执行 wait 休眠操作;
③:给队列中添加数据并唤醒阻塞线程。如果不强制要求添加 synchronized,那么就会出现如下问题:

步骤 线程1 线程2
1 执行步骤 ① 判断当前队列中没有数据

| | 2 |

| 执行步骤 ③ 将数据添加到队列,并唤醒线程1继续执行 | | 3 | 执行步骤 ② 线程 1 进入休眠状态 |

|

从上述执行流程看出问题了吗?如果 wait 和 notify 不强制要求加锁,那么在线程 1 执行完判断之后,尚未执行休眠之前,此时另一个线程添加数据到队列中。然而这时线程 1 已经执行过判断了,所以就会直接进入休眠状态,从而导致队列中的那条数据永久性不能被读取,这就是程序并发运行时“执行结果混乱”的问题。然而如果配合 synchronized 一起使用的话,代码就会变成以下这样:

  1. class MyBlockingQueue {
  2. // 用来保存任务的集合
  3. Queue<String> queue = new LinkedList<>();
  4. /**
  5. * 添加方法
  6. */
  7. public void put(String data) {
  8. synchronized (MyBlockingQueue.class) {
  9. // 队列加入数据
  10. queue.add(data);
  11. // 为了防止 take 方法阻塞休眠,这里需要调用唤醒方法 notify
  12. notify(); // ③
  13. }
  14. }
  15. /**
  16. * 获取方法(阻塞式执行)
  17. * 如果队列里面有数据则返回数据,如果没有数据就阻塞等待数据
  18. * @return
  19. */
  20. public String take() throws InterruptedException {
  21. synchronized (MyBlockingQueue.class) {
  22. // 使用 while 判断是否有数据(这里使用 while 而非 if 是为了防止虚假唤醒)
  23. while (queue.isEmpty()) { // ①
  24. // 没有任务,先阻塞等待
  25. wait(); // ②
  26. }
  27. }
  28. return queue.remove(); // 返回数据
  29. }
  30. }

这样改造之后,关键步骤 ① 和关键步骤 ② 就可以一起执行了,从而当线程执行了步骤 ③ 之后,线程 1 就可以读取到队列中的那条数据了,它们的执行流程如下:

步骤 线程1 线程2
1 执行步骤 ① 判断当前队列没有数据
2 执行步骤 ② 线程进入休眠状态
3
执行步骤 ③ 将数据添加到队列,并执行唤醒操作
4 线程被唤醒,继续执行
5 判断队列中有数据,返回数据

这样咱们的程序就可以正常执行了,这就是为什么 Java 设计一定要让 wait 和 notify 配合上 synchronized 一起使用的原因了。

总结

本文介绍了 wait 和 notify 的基础使用,以及为什么 wait 和 notify/notifyAll 一定要配合 synchronized 使用的原因。如果 wait 和 notify/notifyAll 不强制和 synchronized 一起使用,那么在多线程执行时,就会出现 wait 执行了一半,然后又执行了添加数据和 notify 的操作,从而导致线程一直休眠的缺陷。