作者：忘净空
链接：https://www.jianshu.com/p/91d...
兴许咱们只晓得wait和notify是实现线程通信的，同时要应用synchronized包住，其实在开发中晓得这个是远远不够的。接下来看看两个常见的问题。
问题一：告诉失落
创立2个线程，一个线程负责计算，一个线程负责获取计算结果。
public class Calculator extends Thread { int total; @Override public void run() { synchronized (this){ for(int i = 0; i < 101; i++){ total += i; } this.notify(); } }}public class ReaderResult extends Thread { Calculator c; public ReaderResult(Calculator c) { this.c = c; } @Override public void run() { synchronized (c) { try { System.out.println(Thread.currentThread() + "期待计算结..."); c.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread() + "计算结果为:" + c.total); } } public static void main(String[] args) { Calculator calculator = new Calculator(); //先启动获取计算结果线程 new ReaderResult(calculator).start(); calculator.start(); }}咱们会取得预期的后果：
Thread[Thread-1,5,main]期待计算结...Thread[Thread-1,5,main]计算结果为:5050然而咱们批改为先启动计算线程呢？
calculator.start();new ReaderResult(calculator).start();这是获取结算后果线程始终期待：
Thread[Thread-1,5,main]期待计算结...问题剖析
打印出线程堆栈：
"Thread-1" prio=5 tid=0x00007f983b87e000 nid=0x4d03 in Object.wait() [0x0000000118988000] java.lang.Thread.State: WAITING (on object monitor) at java.lang.Object.wait(Native Method) - waiting on <0x00000007d56fb4d0> (a com.concurrent.waitnotify.Calculator) at java.lang.Object.wait(Object.java:503) at com.concurrent.waitnotify.ReaderResult.run(ReaderResult.java:18) - locked <0x00000007d56fb4d0> (a com.concurrent.waitnotify.Calculator)能够看出ReaderResult在Calculator上期待。产生这个景象就是常说的告诉失落，在获取告诉前，告诉提前达到，咱们先计算结果，计算完后再告诉，然而这个时候获取后果没有在期待告诉，等到获取后果的线程想获取后果时，这个告诉曾经告诉过了，所以就产生失落，那咱们该如何防止?能够设置变量示意是否被告诉过，批改代码如下：
public class Calculator extends Thread { int total; boolean isSignalled = false; @Override public void run() { synchronized (this) { isSignalled = true;//曾经告诉过 for (int i = 0; i < 101; i++) { total += i; } this.notify(); } }}public class ReaderResult extends Thread { Calculator c; public ReaderResult(Calculator c) { this.c = c; } @Override public void run() { synchronized (c) { if (!c.isSignalled) {//判断是否被告诉过 try { System.out.println(Thread.currentThread() + "期待计算结..."); c.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread() + "计算结果为:" + c.total); } } } public static void main(String[] args) { Calculator calculator = new Calculator(); new ReaderResult(calculator).start(); calculator.start(); }}问题二：假唤醒
两个线程去删除数组的元素，当没有元素的时候期待，另一个线程增加一个元素，增加完后告诉删除数据的线程。
public class EarlyNotify{ private List list; public EarlyNotify() { list = Collections.synchronizedList(new LinkedList()); } public String removeItem() throws InterruptedException { synchronized ( list ) { if ( list.isEmpty() ) { //问题在这 list.wait(); } //删除元素 String item = (String) list.remove(0); return item; } } public void addItem(String item) { synchronized ( list ) { //增加元素 list.add(item); //增加后，告诉所有线程 list.notifyAll(); } } private static void print(String msg) { String name = Thread.currentThread().getName(); System.out.println(name + ": " + msg); } public static void main(String[] args) { final EarlyNotify en = new EarlyNotify(); Runnable runA = new Runnable() { public void run() { try { String item = en.removeItem(); } catch ( InterruptedException ix ) { print("interrupted!"); } catch ( Exception x ) { print("threw an Exception!!!\n" + x); } } }; Runnable runB = new Runnable() { public void run() { en.addItem("Hello!"); } }; try { //启动第一个删除元素的线程 Thread threadA1 = new Thread(runA, "threadA1"); threadA1.start(); Thread.sleep(500); //启动第二个删除元素的线程 Thread threadA2 = new Thread(runA, "threadA2"); threadA2.start(); Thread.sleep(500); //启动减少元素的线程 Thread threadB = new Thread(runB, "threadB"); threadB.start(); Thread.sleep(1000); // wait 10 seconds threadA1.interrupt(); threadA2.interrupt(); } catch ( InterruptedException x ) {} }}后果：
threadA1: threw an Exception!!!java.lang.IndexOutOfBoundsException: Index: 0, Size: 0这里产生了假唤醒，当增加完一个元素而后唤醒两个线程去删除，这个只有一个元素，所以会抛出数组越界，这时咱们须要唤醒的时候在判断一次是否还有元素。
批改代码：
public String removeItem() throws InterruptedException { synchronized ( list ) { while ( list.isEmpty() ) { //问题在这 list.wait(); } //删除元素 String item = (String) list.remove(0); return item; }}期待/告诉的典型范式
从下面的问题咱们可演绎出期待/告诉的典型范式。
该范式分为两局部，别离针对期待方（消费者）和告诉方（生产者）。
期待方遵循原则如下：
- 获取对象的锁
- 如果条件不满足，那么调用对象的wait()办法，被告诉后仍要查看条件
- 条件满足则执行对应的逻辑
对应伪代码如下：
synchronized(对象){ while(条件不满足){ 对象.wait(); } 对应的解决逻辑}告诉方遵循原则如下：
- 取得对象的锁
- 扭转条件
- 告诉所以期待在对象上的线程
对应伪代码如下：
synchronized(对象){ 扭转条件 对象.notifyAll();}近期热文举荐：
1.1,000+ 道 Java面试题及答案整顿(2021最新版)
2.终于靠开源我的项目弄到 IntelliJ IDEA 激活码了，真香！
3.阿里 Mock 工具正式开源，干掉市面上所有 Mock 工具！
4.Spring Cloud 2020.0.0 正式公布，全新颠覆性版本！
5.《Java开发手册（嵩山版）》最新公布，速速下载！
感觉不错，别忘了顺手点赞+转发哦！