当前位置：首页 > news >正文

notify和notifyAll

news 来源：原创 2025/6/28 18:30:38

notify和notifyAll

简单来说：

notify()：只唤醒一个等待的线程，如果有多个线程在等待，那么被唤醒的线程是随机选择的。
notifyAll()：唤醒在该对象监视器上等待的所有线程，但是这些被唤醒的线程仍然需要竞争锁，只有一个线程能够获取锁并继续执行。

区别：

notify 可能会导致死锁，而 notifyAll 则不会

任何时候只有一个线程可以获得锁，也就是说只有一个线程可以运行 synchronized 中的代码

使用 notifyall，可以唤醒所有处于 wait 状态的线程，使其重新进入锁的争夺队列中，而 notify只能唤醒一个。

wait() 应配合 while 循环使用，不应使用 if，务必在 wait(）调用前后都检查条件，如果不满足，必须调用 notify(）唤醒另外的线程来处理，自己继续 wait(）直至条件满足再往下执行。

notify() 是对 notifyAll(）的一个优化，但它有很精确的应用场景，并且要求正确使用。不然可能导致死锁。正确的场景应该是 WaitSet 中等待的是相同的条件，唤醒任一个都能正确处理接下来的事项，如果唤醒的线程无法正确处理，务必确保继续 notify(）下一个线程，并且自身需要重新回到 WaitSet 中.

详细来说：

定义和所属类
- notify和notifyAll方法都是Object类中的方法，和wait方法一样，它们是用于线程间通信的机制，基于对象的内部锁（monitor）来操作。
notify方法
- 功能描述：
  - notify方法用于唤醒一个正在等待该对象锁的线程。当一个线程调用notify方法时，它会从等待该对象的线程集合中随机选择一个线程，并将其唤醒，使其从等待状态变为就绪状态，等待获取对象的锁后继续执行。
- 使用场景和目的：
  - 选择性唤醒：在一些特定的多线程场景下，只需要唤醒一个满足特定条件的线程时使用。例如，在一个线程池模型中，有多个工作线程等待任务，当一个任务完成后，只需要唤醒一个空闲的工作线程来获取下一个任务即可。
  - 精细的线程调度：当对线程的执行顺序有一定的控制要求，并且可以确定每次只需要唤醒一个线程就能满足业务逻辑时使用。比如，在一个优先级队列的消费者线程场景中，可能根据任务的优先级，每次只需要唤醒一个具有最高优先级任务处理能力的线程。
- 示例：
  - 假设有一个简单的生产者 - 消费者场景，有一个共享的缓冲区和两个消费者线程（Consumer1和Consumer2）等待数据。当生产者生产出一个数据后，它可以调用notify方法唤醒一个消费者线程来消费这个数据。

 class Buffer {private Object data;private boolean isDataAvailable = false;public synchronized void put(Object data) {while (isDataAvailable) {try {wait();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}this.data = data;System.out.println("put: " + data);isDataAvailable = true;notifyAll();}public synchronized Object get() {while (!isDataAvailable) {try {wait();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}isDataAvailable = false;Object result = data;notify();return result;}}class Consumer implements Runnable {private Buffer buffer;private String name;public Consumer(Buffer buffer) {this.buffer = buffer;}public Consumer(Buffer buffer, String name) {this.buffer = buffer;this.name = name;}@Overridepublic void run() {try {while (true) {Object data = buffer.get();System.out.println(name + " got: " + data);}} catch (Exception e) {e.printStackTrace();}}}class Producer implements Runnable {private Buffer buffer;public Producer(Buffer buffer) {this.buffer = buffer;}@Overridepublic void run() {try {int i = 0;while (true) {buffer.put(i++);Thread.sleep(1000);}} catch (Exception e) {e.printStackTrace();}}}public class NotifyExample {public static void main(String[] args) {Buffer buffer = new Buffer();Thread consumer1 = new Thread(new Consumer(buffer,"consumer1"));Thread consumer2 = new Thread(new Consumer(buffer,"consumer2"));Thread consumer3 = new Thread(new Consumer(buffer,"consumer3"));Thread consumer4 = new Thread(new Consumer(buffer,"consumer4"));Thread producer = new Thread(new Producer(buffer));Thread producer2 = new Thread(new Producer(buffer));Thread producer3 = new Thread(new Producer(buffer));Thread producer4 = new Thread(new Producer(buffer));Thread producer5 = new Thread(new Producer(buffer));consumer1.start();consumer2.start();consumer3.start();consumer4.start();producer.start();producer2.start();producer3.start();producer4.start();producer5.start();}}

在这个示例中，put方法和get方法是同步的，生产者在放入数据后调用notify唤醒一个消费者线程，消费者在获取数据后也调用notify唤醒可能等待的生产者线程。

notifyAll方法
- 功能描述：
  - notifyAll方法会唤醒所有正在等待该对象锁的线程。被唤醒的线程会从等待状态变为就绪状态，然后它们会竞争对象的锁，只有获取到锁的线程才能继续执行。
- 使用场景和目的：
  - 广播通知：当多个线程都在等待同一个对象的状态改变，并且需要所有等待线程都有机会去检查和处理新的状态时使用。例如，在一个资源池模型中，当资源被释放回池中，需要唤醒所有等待资源的线程，让它们去竞争获取资源。
  - 不确定唤醒数量的场景：当无法确定具体需要唤醒多少个线程才能满足业务逻辑时，使用notifyAll比较保险。比如，在一个复杂的多线程数据处理系统中，有多个线程等待数据更新，每次数据更新后，使用notifyAll让所有等待线程自己判断是否需要处理新数据。
- 示例：
  - 同样是生产者 - 消费者场景，但当有新数据产生时，生产者希望所有等待的消费者都有机会获取数据。可以将put方法中的notify改为notifyAll。

 class Buffer {private Object data;private boolean isDataAvailable = false;public synchronized void put(Object data) {while (isDataAvailable) {try {wait();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}this.data = data;isDataAvailable = true;notifyAll();}//...其他方法和之前类似}

在这种情况下，所有等待在buffer对象上的消费者线程都会被唤醒，然后它们会竞争获取buffer对象的锁来获取数据

notify方法导致死锁的原理
- 部分线程未被唤醒：
  - notify方法只会唤醒一个等待该对象锁的线程。在多线程环境下，如果有多个线程在等待同一个对象的锁，并且这些线程的唤醒条件比较复杂，使用notify可能会导致部分线程永远无法被唤醒。例如，在一个生产者 - 消费者模型中，有多个消费者线程等待一个共享缓冲区（对象）中的产品。如果生产者线程只使用notify方法来唤醒消费者线程，可能会出现这样的情况：总是唤醒同一个消费者线程，而其他消费者线程一直处于等待状态。
- 等待条件未满足的唤醒：
  - 更严重的是，被唤醒的线程可能由于条件不满足而无法继续执行，并且再次进入等待状态。假设消费者线程被唤醒后，发现共享缓冲区中的产品不符合自己的需求（例如，消费者线程需要特定类型的产品，而缓冲区中的产品不是它所需要的），它可能会再次调用wait方法进入等待状态。如果这种情况不断发生，所有的线程都可能陷入等待，导致死锁。
- 与锁获取顺序冲突：
  - 死锁还可能因为锁获取顺序的冲突而产生。考虑这样一个场景，有两个共享对象 A 和 B，以及两个线程 T1 和 T2。T1 持有对象 A 的锁并且在等待对象 B 的锁，同时 T2 持有对象 B 的锁并且在等待对象 A 的锁。如果notify方法在这种情况下被不恰当使用，例如在 T1 等待对象 B 的锁时，T2 调用notify唤醒 T1，但是 T1 由于无法获取对象 B 的锁而无法继续执行，同时 T2 也在等待对象 A 的锁，这样就会导致两个线程都无法继续执行，从而产生死锁。
示例说明
- 代码示例：
  - 假设有两个线程 T1 和 T2，以及一个共享对象sharedObj，代码如下：

        class SharedObject {private boolean flag = false;public synchronized void method1() {while (!flag) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}// 执行一些操作，假设这里会改变共享资源的状态flag = false;// 通知其他线程notify();}public synchronized void method2() {while (flag) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}// 执行一些操作，假设这里会改变共享资源的状态flag = true;// 通知其他线程notify();}}public class Main {public static void main(String[] args) {final SharedObject sharedObj = new SharedObject();Thread t1 = new Thread(() -> {for (int i = 0; i < 10; i++) {sharedObj.method1();}});Thread t2 = new Thread(() -> {for (int i = 0; i < 10; i++) {sharedObj.method2();}});t1.start();t2.start();}}

死锁分析：
- 在这个例子中，method1和method2是共享对象sharedObj的两个同步方法。线程 T1 执行method1，线程 T2 执行method2。method1在flag为假时等待，method2在flag为真时等待。当 T1 被唤醒后，它会将flag设置为假并通知其他线程；当 T2 被唤醒后，它会将flag设置为真并通知其他线程。
- 假设 T1 先执行，进入method1后发现flag为假，调用wait等待。然后 T2 执行method2，将flag设置为真并通知 T1。T1 被唤醒后，执行完自己的操作将flag设置为假并通知 T2。此时，如果 T2 已经再次调用wait等待（因为flag变为假），而 T1 也在等待下一次flag变为真，就会出现两个线程都在等待对方改变flag的值，从而导致死锁。

notify和notifyAll

相关文章：