线程间通信的模型有两种：共享内存 和 消息传递，以下方式都是基本这两种模型来实现的。
我们来基本一道面试常见的题目来分析：
对一个值两个线程对其交替 +1 -1 （线程间通信）

每个线程主要做五件事：
上锁
判断(等待)
干活
通知
解锁

3.1 synchronized 方案

  1. package juc.wait3;
  3. import java.util.concurrent.Callable;
  5. /**
  6.  * @Author Rock Wang
  7.  * @Time 2021/11/3
  8.  */
  9. public class Main {
  11.     public static void main(String[] args) {
  12.         Share share = new Share();
  13.         new Thread(() -> {
  14.             for (int i = 0; i < 30; i++) {
  15.                 try {
  16.                     share.incr();
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         }, "AA").start();
  23.         new Thread(() -> {
  24.             for (int i = 0; i < 30; i++) {
  25.                 try {
  26.                     share.decr();
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.             }
  31.         }, "BB").start();
  32.     }
  34. }
  36. /**
  37.  * Share 共享
  38.  */
  39. class Share {
  41.     private int number = 0;
  43.     /**
  44.      * +1
  45.      */
  46.     public synchronized void incr() throws InterruptedException {
  47.         //判断 干活 通知
  48.         //if (number != 0) {
  49.         while (number != 0) {
  50.             this.wait();
  51.         }
  52.         number++;
  53.         System.out.println(Thread.currentThread().getName() + ",number :" + number);
  54.         //唤醒其他所有线程
  55.         this.notifyAll();
  56.     }
  58.     /**
  59.      * -1
  60.      */
  61.     public synchronized void decr() throws InterruptedException {
  62.         //if (number != 1) {
  63.         while (number != 1) {
  64.             this.wait();
  65.         }
  66.         number--;
  67.         System.out.println(Thread.currentThread().getName() + ",number :" + number);
  68.         //唤醒其他所有线程
  69.         this.notifyAll();
  70.     }
  72. }

如果线程超过两个，if判断的过程会出现虚假唤醒问题，导致无法交替加减。
wait() 在哪里睡，在哪里被唤醒，导致if无效，更换while循环即可。

四个线程
AA ++
BB —
CC ++
DD —

都是调用start方法创建，但是先后顺序不一定，睡眠唤醒也不一定。

例子：坐飞机，下飞机再登机需要重新安检（while）。

3.2 Lock 方案

Condition 状况，状态；条件，环境

  1. package juc.lock2;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * @Author Rock Wang
  9.  * @Time 2021/11/3
  10.  */
  11. public class Await4 {
  12.     public static void main(String[] args) {
  13.         Share share = new Share();
  14.         for (int i = 0; i < 20; i++) {
  15.             new Thread(() -> {
  16.                 try {
  17.                     share.incr();
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.             }, "AA").start();
  23.             new Thread(() -> {
  24.                 try {
  25.                     share.decr();
  26.                 } catch (InterruptedException e) {
  27.                     e.printStackTrace();
  28.                 }
  29.             }, "BB").start();
  31.             new Thread(() -> {
  32.                 try {
  33.                     share.incr();
  34.                 } catch (InterruptedException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.             }, "CC").start();
  39.             new Thread(() -> {
  40.                 try {
  41.                     share.decr();
  42.                 } catch (InterruptedException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }, "DD").start();
  46.         }
  47.     }
  48. }
  50. /**
  51.  * Condition  状况，状态；条件，环境
  52.  */
  53. class Share {
  54.     private int number = 0;
  56.     private Lock lock = new ReentrantLock();
  57.     private Condition condition = lock.newCondition();
  59.     /**
  60.      * ++
  61.      */
  62.     public void incr() throws InterruptedException {
  63.         //上锁
  64.         lock.lock();
  65.         try {
  66.             //判断 干活 通知
  67.             while (number != 0) {
  68.                 //等待
  69.                 condition.await();
  70.             }
  71.             number++;
  72.             System.out.println(Thread.currentThread().getName() + ",number :" + number);
  74.             condition.signalAll();
  75.         } finally {
  76.             //解锁
  77.             lock.unlock();
  78.         }
  79.     }
  81.     /**
  82.      * --
  83.      */
  85.     public void decr() throws InterruptedException {
  86.         lock.lock();
  87.         try {
  88.             while (number != 1) {
  89.                 condition.await();
  90.             }
  91.             number--;
  92.             System.out.println(Thread.currentThread().getName() + ",number :" + number);
  94.             condition.signalAll();
  95.         } finally {
  96.             lock.unlock();
  97.         }
  98.     }
  100. }

Condition
await();
signalAll();

3.3线程间定制化通信

==问题: A线程打印5次A，B线程打印10次B，C线程打印15次C,按照此顺序循环10轮==
关键点：需要让线程按照顺序执行。
image.png
1.分别加标志位 flag = 1 2 3
2.判断标志位 1，打印
3.修改标志位 2，通知BB
4.判断标志位 2，打印
5.修改标志位 3，通知CC
6.判断标志位 3，打印
7.修改标志位 1，通知AA
…循环10次

  1. package juc.lock2;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * @Author Rock Wang
  9.  * @Time 2021/11/3
  10.  */
  11. public class ThreadDemo3 {
  13.     public static void main(String[] args) {
  14.         ShareResult shareResult = new ShareResult();
  16.         new Thread(() -> {
  17.             for (int i = 1; i <= 10; i++) {
  18.                 try {
  19.                     shareResult.print5(i);
  20.                 } catch (InterruptedException e) {
  21.                     e.printStackTrace();
  22.                 }
  23.             }
  24.         }, "AA").start();
  27.         new Thread(() -> {
  28.             for (int i = 1; i <= 10; i++) {
  29.                 try {
  30.                     shareResult.print10(i);
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }, "BB").start();
  38.         new Thread(() -> {
  39.             for (int i = 1; i <= 10; i++) {
  40.                 try {
  41.                     shareResult.print15(i);
  42.                 } catch (InterruptedException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.         }, "CC").start();
  47.     }
  48. }
  50. /**
  51.  * 创建资源类
  52.  */
  53. class ShareResult {
  54.     /**
  55.      * 1:AA
  56.      * 2:BB
  57.      * 3:CC
  58.      */
  59.     private int flag = 1;
  61.     /**
  62.      * 创建Lock锁
  63.      */
  64.     private Lock lock = new ReentrantLock();
  66.     /**
  67.      * 创建三个Condition
  68.      */
  69.     private Condition c1 = lock.newCondition();
  70.     private Condition c2 = lock.newCondition();
  71.     private Condition c3 = lock.newCondition();
  73.     /**
  74.      * 打印五次
  75.      *
  76.      * @param loop 第几轮
  77.      */
  78.     public void print5(int loop) throws InterruptedException {
  79.         //上锁
  80.         lock.lock();
  81.         try {
  82.             //判断
  83.             while (flag != 1) {
  84.                 c1.await();
  85.             }
  86.             for (int i = 0; i < 5; i++) {
  87.                 // 干活
  88.                 System.out.println(Thread.currentThread().getName() + " :: " + (i + 1) + ",轮数: " + loop);
  89.             }
  90.             //修改标志位
  91.             flag = 2;
  92.             //通知
  93.             c2.signalAll();
  94.         } finally {
  95.             lock.unlock();
  96.         }
  97.     }
  99.     /**
  100.      * 打印10次
  101.      *
  102.      * @param loop 第几轮
  103.      */
  104.     public void print10(int loop) throws InterruptedException {
  105.         //上锁
  106.         lock.lock();
  107.         try {
  108.             //判断
  109.             while (flag != 2) {
  110.                 c2.await();
  111.             }
  112.             for (int i = 0; i < 10; i++) {
  113.                 // 干活
  114.                 System.out.println(Thread.currentThread().getName() + " :: " + (i + 1) + ",轮数: " + loop);
  115.             }
  116.             //修改标志位
  117.             flag = 3;
  118.             //通知
  119.             c3.signalAll();
  120.         } finally {
  121.             lock.unlock();
  122.         }
  123.     }
  125.     /**
  126.      * 打印15次
  127.      *
  128.      * @param loop 第几轮
  129.      */
  130.     public void print15(int loop) throws InterruptedException {
  131.         //上锁
  132.         lock.lock();
  133.         try {
  134.             //判断
  135.             while (flag != 3) {
  136.                 c3.await();
  137.             }
  138.             //干活
  139.             for (int i = 0; i < 15; i++) {
  140.                 System.out.println(Thread.currentThread().getName() + " :: " + (i + 1) + ",轮数: " + loop);
  141.             }
  142.             //修改标志位
  143.             flag = 1;
  144.             //通知
  145.             c1.signalAll();
  146.         } finally {
  147.             lock.unlock();
  148.         }
  149.     }
  150. }