关于后端:面试突击24为什么wait和notify必须放在synchronized中

在多线程编程中，wait 办法是让以后线程进入休眠状态，直到另一个线程调用了 notify 或 notifyAll 办法之后，能力持续复原执行。而在 Java 中，wait 和 notify/notifyAll 有着一套本人的应用格局要求，也就是在应用 wait 和 notify（notifyAll 的应用和 notify 相似，所以下文就只用 notify 用来指代二者）必须配合 synchronized 一起应用才行。

wait 和 notify 的根底办法如下：

Object lock = new Object();
new Thread(() -> {synchronized (lock) {
        try {System.out.println("wait 之前");
            // 调用 wait 办法
            lock.wait();
            System.out.println("wait 之后");
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
}).start();

Thread.sleep(100);
synchronized (lock) {System.out.println("执行 notify");
    // 调用 notify 办法
    lock.notify();}

以上代码的执行后果如下图所示：

那问题来了，是不是 wait 和 notify 肯定要配合 synchronized 一起应用呢？wait 和 notify 独自应用行不行呢？
咱们尝试将以上代码中的 synchronized 代码行删除，实现代码如下：

初看代码如同没啥问题，编译器也没报错，如同能“失常应用”，然而当咱们运行以上程序时就会产生如下谬误：

从上述后果能够看出：无论是 wait 还是 notify，如果不配合 synchronized 一起应用，在程序运行时就会报 IllegalMonitorStateException 非法的监视器状态异样，而且 notify 也不能实现程序的唤醒性能了。

从上述的报错信息咱们能够看出，JVM 在运行时会强制查看 wait 和 notify 有没有在 synchronized 代码中，如果没有的话就会报非法监视器状态异样（IllegalMonitorStateException），但这也仅仅是运行时的程序表象，那为什么 Java 要这样设计呢？
其实这样设计的起因 就是为了避免多线程并发运行时，程序的执行凌乱问题。初看这句话，如同是用来形容“锁”的。然而理论状况也是如此，wait 和 notify 引入锁就是来躲避并发执行时程序的执行凌乱问题的。那这个“执行凌乱问题”到底是啥呢？接下来咱们持续往下看。

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

class MyBlockingQueue {
    // 用来保留数据的汇合
    Queue<String> queue = new LinkedList<>();

    /**
     * 增加办法
     */
    public void put(String data) {
        // 队列退出数据
        queue.add(data); 
        // 唤醒线程继续执行（这里的线程指的是执行 take 办法的线程）notify(); // ③}

    /**
     * 获取办法（阻塞式执行）* 如果队列外面有数据则返回数据，如果没有数据就阻塞期待数据
     * @return
     */
    public String take() throws InterruptedException {
        // 应用 while 判断是否有数据（这里应用 while 而非 if 是为了避免虚伪唤醒）while (queue.isEmpty()) { // ①  
            // 没有工作，先阻塞期待
            wait(); // ②}
        return queue.remove(); // 返回数据}
}

留神上述代码，咱们在代码中标识了三个要害执行步骤：①：判断队列中是否有数据；②：执行 wait 休眠操作；③：给队列中增加数据并唤醒阻塞线程。
如果不强制要求增加 synchronized，那么就会呈现如下问题：

步骤	线程 1	线程 2
1	执行步骤 ① 判断以后队列中没有数据
2		执行步骤 ③ 将数据增加到队列，并唤醒线程 1 继续执行
3	执行步骤 ② 线程 1 进入休眠状态

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

class MyBlockingQueue {
    // 用来保留工作的汇合
    Queue<String> queue = new LinkedList<>();

    /**
     * 增加办法
     */
    public void put(String data) {synchronized (MyBlockingQueue.class) {
            // 队列退出数据
            queue.add(data);
            // 为了避免 take 办法阻塞休眠，这里须要调用唤醒办法 notify
            notify(); // ③}
    }

    /**
     * 获取办法（阻塞式执行）* 如果队列外面有数据则返回数据，如果没有数据就阻塞期待数据
     * @return
     */
    public String take() throws InterruptedException {synchronized (MyBlockingQueue.class) {
            // 应用 while 判断是否有数据（这里应用 while 而非 if 是为了避免虚伪唤醒）while (queue.isEmpty()) {  // ①
                // 没有工作，先阻塞期待
                wait(); // ②}
        }
        return queue.remove(); // 返回数据}
}

这样革新之后，关键步骤 ① 和关键步骤 ② 就能够一起执行了，从而当线程执行了步骤 ③ 之后，线程 1 就能够读取到队列中的那条数据了，它们的执行流程如下：

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

这样咱们的程序就能够失常执行了，这就是为什么 Java 设计肯定要让 wait 和 notify 配合上 synchronized 一起应用的起因了。

本文介绍了 wait 和 notify 的根底应用，以及为什么 wait 和 notify/notifyAll 肯定要配合 synchronized 应用的起因。如果 wait 和 notify/notifyAll 不强制和 synchronized 一起应用，那么在多线程执行时，就会呈现 wait 执行了一半，而后又执行了增加数据和 notify 的操作，从而导致线程始终休眠的缺点。

是非审之于己，毁誉听之于人，得失安之于数。

公众号：Java 面试真题解析

面试合集：https://gitee.com/mydb/interview

关于后端:面试突击24为什么wait和notify必须放在synchronized中

wait/notify 根底应用

wait/notify 和 synchronized 一起用？

起因剖析

wait 和 notify 问题复现

总结