尽量使用notifyAll，而不用notify

朱雀 2021-06-22 15:38 422阅读 0赞

#### wait与notify，notifyAll ####

他们都是Object类的方法，一般用在synchronized代码块中，用于当线程某个条件不满足时，通过wait()挂起线程，将线程加入到阻塞队列中。而当条件满足时，通过notify唤醒阻塞的线程，被唤醒的线程将会从wait()阻塞的位置继续执行。  
这是官方推荐的使用格式是：

synchronized (obj) { 
           while (条件不成立)
                obj.wait();
          ... // Perform action appropriate to condition
        }

通过以上的方式，当线程被唤醒时，会继续判断条件是否成立。如果成立，则继续执行。  
notify与notifyAll的区别是：notify一次只唤醒一个线程，notifyAll会唤醒阻塞队列中的所有线程。

#### 为什么建议尽量使用notifyAll，而不用notify ####

看个例子：

package juc;
    
    /** * <pre>类名: ObjectWaitNotifyTest</pre> * <pre>描述: 等待-通知机制</pre> * <pre>版权: web_chen@163.com</pre> * <pre>日期: 2020/11/5 11:06</pre> * <pre>作者: chenwb</pre> */
    public class ObjectWaitNotifyTest { 
    	/** * 共享变量 */
    	private int shareVal = 0;
    
    	public synchronized void addShareVal1() throws InterruptedException { 
    		while (shareVal % 3 != 0) { 
    			wait();
    		}
    		shareVal++;
    		System.out.println(shareVal);
    		notify();
    	}
    
    	public synchronized void addShareVal2() throws InterruptedException { 
    		while (shareVal % 3 != 1) { 
    			wait();
    		}
    		shareVal++;
    		System.out.println(shareVal);
    		notify();
    	}
    
    	public synchronized void addShareVal3() throws InterruptedException { 
    		while (shareVal % 3 != 2) { 
    			wait();
    		}
    		shareVal++;
    		System.out.println(shareVal);
    		notify();
    	}
    
    	public static void main(String[] args) throws InterruptedException { 
    		ObjectWaitNotifyTest objectWaitNotify = new ObjectWaitNotifyTest();
    		Thread t1 = new Thread(() -> { 
    			try { 
    				for (; ; ) objectWaitNotify.addShareVal1();
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		},"t1");
    
    		Thread t2 = new Thread(() -> { 
    			try { 
    				for (;;) objectWaitNotify.addShareVal2();
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		},"t2");
    
    		Thread t3 = new Thread(() -> { 
    			try { 
    				for (; ; ) objectWaitNotify.addShareVal3();
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		},"t3");
    
    		t1.start();
    		t2.start();
    		t3.start();
    		t1.join();
    		t2.join();
    		t3.join();
    	}
    }

上例中我定义了三个线程，一个线程只能对3的倍数做+1操作，一个线程只能对3的倍数多1的数做+1操作，一个线程只能对3的倍数多2的数做+1操作，否则线程就会被挂起，等待条件符合。  
这里的wait()与notify()等价于this.wait()与this.notify()，锁的是当前对象。  
当执行完+1操作之后，就唤醒下一个线程，看似没什么问题。  
执行代码结果：

1
    2

执行不下去了。。。  
通过jstack -l pid 查看线程状态：

"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x0000000054013000 nid=0x349c in Object.wait() [0x000000005552f000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000f56898b0> (a java.lang.ref.ReferenceQueue$Lock)
            at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
            - locked <0x00000000f56898b0> (a java.lang.ref.ReferenceQueue$Lock)
            at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
            at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)
    
       Locked ownable synchronizers:
            - None
    
    "Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x0000000053fcb000 nid=0x23ac in Object.wait() [0x000000005542f000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000f5689ae0> (a java.lang.ref.Reference$Lock)
            at java.lang.Object.wait(Object.java:502)
            at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
            - locked <0x00000000f5689ae0> (a java.lang.ref.Reference$Lock)
            at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)
    
       Locked ownable synchronizers:
            - None

可以看到线程是阻塞的无法继续执行。

#### 原因分析 ####

正因为notify只随机唤醒一个阻塞线程，如果t1,t2线程都阻塞了，线程t3执行完+1之后执行notify，而唤醒的线程是t2,而t2不满足执行条件，线程t1的条件才是符合的。此时线程就都阻塞了。  
而使用notifyAll，会唤醒所有阻塞线程，只要有一个线程符合条件就可以继续执行，就不会出现这种情况了。

#### 将notify改为notifyAll ####

package juc;
    
    /** * <pre>类名: ObjectWaitNotifyTest</pre> * <pre>描述: 等待-通知机制</pre> * <pre>版权: web_chen@163.com</pre> * <pre>日期: 2020/11/5 11:06</pre> * <pre>作者: chenwb</pre> */
    public class ObjectWaitNotifyTest { 
    
    	/** * 共享变量 */
    	private int shareVal = 0;
    
    	public synchronized void addShareVal1() throws InterruptedException { 
    		while (shareVal % 3 != 0) { 
    			wait();
    		}
    		shareVal++;
    		System.out.println(shareVal);
    		notifyAll();
    	}
    
    	public synchronized void addShareVal2() throws InterruptedException { 
    		while (shareVal % 3 != 1) { 
    			wait();
    		}
    		shareVal++;
    		System.out.println(shareVal);
    		notifyAll();
    	}
    
    	public synchronized void addShareVal3() throws InterruptedException { 
    		while (shareVal % 3 != 2) { 
    			wait();
    		}
    		shareVal++;
    		System.out.println(shareVal);
    		notifyAll();
    	}
    
    	public static void main(String[] args) throws InterruptedException { 
    		ObjectWaitNotifyTest objectWaitNotify = new ObjectWaitNotifyTest();
    		Thread t1 = new Thread(() -> { 
    			try { 
    				for (; ; ) objectWaitNotify.addShareVal1();
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		},"t1");
    
    		Thread t2 = new Thread(() -> { 
    			try { 
    				for (;;) objectWaitNotify.addShareVal2();
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		},"t2");
    
    		Thread t3 = new Thread(() -> { 
    			try { 
    				for (; ; ) objectWaitNotify.addShareVal3();
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		},"t3");
    
    		t1.start();
    		t2.start();
    		t3.start();
    		t1.join();
    		t2.join();
    		t3.join();
    	}
    }

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    ...
    ...

执行成功！

#### 小结 ####

1、notifyAll相比notify，是更加耗性能的，但是更加稳妥。相比安全，可靠来说，耗费一点性能是可以接受的。  
2、除非你完全确定，否则建议你使用notifyAll替代notify。  
使用notify的条件：

*  所有等待线程拥有相同的等待条件；
 *  所有等待线程被唤醒后，执行相同的操作；
 *  只需要唤醒一个线程。