为什么wait/notify方法要写在synchronized代码块中？

互联网渣渣东

已于 2022-04-11 17:07:12 修改

阅读量1.5k

点赞数

分类专栏： Java基础文章标签： java

于 2022-04-11 17:02:16 首次发布

本文链接：https://blog.youkuaiyun.com/A_dg_Jffery/article/details/124097993

版权

Java基础专栏收录该内容

9 篇文章

订阅专栏

本文详细解释了Java中wait/notify方法为何必须在synchronized代码块中使用的原因。synchronized用于保证多线程同步，wait()使线程释放锁并等待，notify()唤醒等待队列中的线程。如果不使用synchronized，可能会导致非法状态异常，并影响线程间通信的正确性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

为什么wait/notify方法要配合synchronized使用？

synchronized含义：

Java中每一个对象都可以成为一个监视器（Monitor）, 该Monitor由一个锁（lock）, 一个等待队列(waiting queue), 一个入口队列(entry queue).

对于一个对象的方法，如果没有synchronized关键字，该方法可以被任意数量的线程，在任意时刻调用。

对于添加了synchronized关键字的方法，任意时刻只能被唯一的一个获得了对象实例锁的线程调用。

synchronized用于实现多线程的同步操作

synchronized的三种应用方式，Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

普通同步方法（实例方法），锁是当前实例对象，进入同步代码前要获得当前实例的锁
静态同步方法，锁是当前类的class对象，进入同步代码前要获得当前类对象的锁
同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象。

wait()作用

wait(), notify(), notifyAll() 和 synchonized 需要搭配使用，用于线程同步。

wait()总是在一个循环中被调用，挂起当前线程来等待一个条件的成立。 Wait调用会一直等到其他线程调用notifyAll()时才返回。

当一个线程在执行synchronized 的方法内部，调用了wait()后，该线程会释放该对象的锁，然后该线程会被添加到该对象的等待队列中（waiting queue）, 只要该线程在等待队列中，就会一直处于闲置状态，不会被调度执行。要注意wait()方法会强迫线程先进行释放锁操作，所以在调用wait()时，该线程必须已经获得锁，否则会抛出异常。由于wait()在synchonized的方法内部被执行，锁一定已经获得，就不会抛出异常了。

notify()的功用

wait(), notify(), notifyAll() 和 synchonized 需要搭配使用，用于线程同步。

当一个线程调用一个对象的notify()方法时，调度器会从所有处于该对象等待队列（waiting queue）的线程中取出任意一个线程，将其添加到入口队列( entry queue) 中. 然后在入口队列中的多个线程就会竞争对象的锁，得到锁的线程就可以继续执行。如果等待队列中（waiting queue）没有线程， notify()方法不会产生任何作用。

notifyAll() 和notify()工作机制一样，区别在于notifyAll()会将等待队列（waiting queue）中所有的线程都添加到入口队列中（entry queue）。

为什么wait() / notify() / notifyAll() 要放在synchronized的代码块中使用？

我们可以先来看看，不放在synchronized代码块中使用会有什么问题？

public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        obj.wait();
        obj.notify();
    }

输出结果：

Exception in thread "main" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at xxxx.main(XXX.java:254)

可以看到上面的代码输出结果，直接抛出异常了。下面就讲讲为何会出现这种问题。

wait() 和 notify()是用来实现多个线程之间的一个协调；wait() 表示让线程进入到阻塞状态，notify() 表示让阻塞的线程被唤醒， notifyAll() 则表述唤醒所有被阻塞的线程。 wait() 和 notify() 必然是成对出现的。如果一个线程被wait()方法阻塞，那么必然要另一个线程通过notify() 唤醒，从而实现多个线程之间的通信。

在多线程里面要实现多个线程之间的通信，除了管道以外，只能通过共享变量的方式来实现，也就是说第一个线程修改了公共共享变量，别的线程获得修改后的变量的值，从而完成数据的一个通讯；但是多线程的本身是具有并行执行的一个特性，也就是说，在同一个时间，多个线程是可以同时执行的，那么这种情况下，其它现在在访问共享变量之前，必须要知道，第一个线程已经修改了这个共享变量，否则就需要等待，或者是拿到原始数据，基于此基础上运输，产生数据不一致的场景；同时第一个线程在数据修改后，还需要把那个已经处于等待状态下的其它线程唤醒，所以在这种场景下，需要去实现线程之间的通信就必须要有一个静态条件，去控制多线程什么时候条件等待什么时候条件唤醒。而synchronized关键字就可以实现这样一个互斥条件，也就是在通过共享变量来实现多个线程通信的一个场景里面，参与通信的线程必须竞争到这共享变量的一个锁资源，才能够有资格对共享变量进行修改，那么修改完之后释放锁，其他线程就可以再次竞争同一个共享的锁，来获取修改之后的数据，从而完成线程之间的一个通信；所以这就是为什么wait() / notify() 必须需要在synchronized代码块中使用。

有了synchronized同步锁，就可以实现对于多个通信线程之间的一个互斥，从而实现条件等待和条件互斥的唤醒，另外为了避免wait() 和 notify()的错误使用，JDK强制的要求把wait() 和 notify() 写在了同步代码块中，否则就会抛出IllegalMonitorStateException。

	/* 	<pre>
     *     synchronized (obj) {
     *         while (&lt;condition does not hold&gt;)
     *             obj.wait(timeout, nanos);
     *         ... // Perform action appropriate to condition
     *     }
     * </pre>
     * This method should only be called by a thread that is the owner
     * of this object's monitor. See the {@code notify} method for a
     * description of the ways in which a thread can become the owner of
     * a monitor.
     * 
     * @param      timeout   the maximum time to wait in milliseconds.
     * @param      nanos      additional time, in nanoseconds range
     *                       0-999999.
     * @throws  IllegalArgumentException      if the value of timeout is
     *                      negative or the value of nanos is
     *                      not in the range 0-999999.
     * /