聊聊并发（二）——生产者与消费者

一、等待唤醒机制

1、介绍

　　wait()：一旦执行此方法，当前线程进入阻塞状态，并释放锁。
　　notify()：一旦执行此方法，就会唤醒一个被wait()的线程。如果有多个，就唤醒优先级高的，如果优先级一样，则随机唤醒一个。
　　notifyAll()：一旦执行此方法，会唤醒所有wait()的线程。
　　notify()唤醒线程，不会立即释放锁对象，需要等到当前同步代码块都执行完后才会释放锁对象。下次和被唤醒的线程同时竞争锁对象。
　　问：wait 等待中的线程被 notify 唤醒了会立马执行吗？
　　答：不会。被唤醒的线程需要重新竞争锁对象，获得锁的线程可以从wait处继续往下执行。

2、两个线程交替打印问题

　　如何使用两个线程交替打印1—100？
　　代码示例：先用两个线程来打印1—100。

 1 // 不写注释也能看懂的代码
 2 public class Main {
 3 
 4     public static void main(String[] args) {
 5         Num num = new Num();
 6         Thread thread1 = new Thread(num);
 7         Thread thread2 = new Thread(num);
 8 
 9         thread1.start();
10         thread2.start();
11     }
12 }
13 
14 
15 class Num implements Runnable {
16 
17     private int i = 1;
18 
19     @Override
20     public void run() {
21         while (true) {
22             synchronized (this) {
23                 if (i <= 100) {
24                     System.out.println(Thread.currentThread().getName() + ":" + i);
25                     i++;
26                 } else {
27                     break;
28                 }
29             }
30         }
31     }
32 }
33 
34 // 可能的结果.当然是谁抢到谁打印.
35 Thread-0:1
36 Thread-0:2
37 Thread-1:3
38 Thread-1:4
39 ……

　　理解：两个线程的共享变量是 i ；两个线程共同竞争的锁 this 是num。

　　再看原问题，线程本来是抢占式的，要想实现交替打印。显然，需要线程之间有通信。即，线程A打印 1 之后，阻塞一下，等待线程B打印 2 ，然后唤醒A，并且B阻塞，A打印3，以此内推。这就是线程的等待唤醒机制。
　　代码示例：只需要在上述代码添加两行即可，如下：

 1 class Num implements Runnable {
 2 
 3     private int i = 1;
 4 
 5     @Override
 6     public void run() {
 7         while (true) {
 8             synchronized (this) {
 9                 // 1.先唤醒对方
10                 notify();
11 
12                 if (i <= 100) {
13                     System.out.println(Thread.currentThread().getName() + ":" + i);
14                     i++;
15 
16                     // 2.当前线程操作完后.等待阻塞
17                     try {
18                         wait();
19                     } catch (InterruptedException e) {
20                         e.printStackTrace();
21                     }
22                 } else {
23                     break;
24                 }
25             }
26         }
27     }
28 }

　　图解：

　　代码示例：将上述代码改用Lock实现。

 1 class Num implements Runnable {
 2 
 3     private int i = 1;
 4     // 锁
 5     final private Lock lock = new ReentrantLock();
 6     final Condition condition = lock.newCondition();
 7 
 8     @Override
 9     public void run() {
10         while (true) {
11             // 上锁
12             lock.lock();
13 
14             try {
15                 // 1.先唤醒对方
16                 condition.signal();
17 
18                 if (i <= 100) {
19                     System.out.println(Thread.currentThread().getName() + ":" + i);
20                     i++;
21 
22                     // 2.当前线程操作完后.等待阻塞
23                     try {
24                         condition.await();
25                     } catch (InterruptedException e) {
26                         e.printStackTrace();
27                     }
28                 } else {
29                     break;
30                 }
31             } finally {
32                 // 释放锁
33                 lock.unlock();
34             }
35         }
36     }
37 }

　　使用lock同步锁，就不需要sychronized关键字了，需要创建lock对象和condition实例。Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。
在 Condition 对象中，对应的等待唤醒方法需要改为：
　　wait()方法——await()方法
　　signal()方法——notify()方法
　　signalAll()——notifyAll()方法

3、三个线程交替打印问题

　　在上个问题的基础上，升级一下，考虑三个线程交替打印1—99？
　　思想同理：接力棒A，交给B，B交给C，C交给A。但是如何指定唤醒一个线程呢？notify()只能随机唤醒一个。这里用lock的condition来解决。
　　代码示例：三个线程交替打印

  1 public class Main {
  2 
  3     public static void main(String[] args) {
  4         Num num = new Num();
  5 
  6         new Thread(() -> {
  7             num.loopA();
  8         }).start();
  9 
 10         new Thread(() -> {
 11             num.loopB();
 12         }).start();
 13 
 14         new Thread(() -> {
 15             num.loopC();
 16         }).start();
 17     }
 18 }
 19 
 20 class Num {
 21 
 22     private int i = 1;
 23     // 当前正在执行的线程的标记
 24     private int flag = 1;
 25     final private Lock lock = new ReentrantLock();
 26     final Condition conditionA = lock.newCondition();
 27     final Condition conditionB = lock.newCondition();
 28     final Condition conditionC = lock.newCondition();
 29 
 30     public void loopA() {
 31         while (true) {
 32             // 循环不停的抢锁
 33             lock.lock();
 34 
 35             try {
 36                 // 线程A判断是不是该自己打印
 37                 while (flag != 1) {
 38                     conditionA.await();
 39                 }
 40                 
 41                 // 唤醒线程B
 42                 // 注意这里:先唤醒B,再执行A的.
 43                 // 不要这两行代码放在下面的if中,最后会有线程出不来导致程序结束不了
 44                 conditionB.signal();
 45                 flag = 2;
 46 
 47                 if (i <= 99) {
 48                     System.out.println(Thread.currentThread().getName() + ":" + i);
 49                     i++;
 50 
 51                 } else {
 52                     break;
 53                 }
 54             } catch (InterruptedException e) {
 55                 e.printStackTrace();
 56             } finally {
 57                 lock.unlock();
 58             }
 59         }
 60     }
 61 
 62     // 同理
 63     public void loopB() {
 64         while (true) {
 65             lock.lock();
 66 
 67             try {
 68                 while (flag != 2) {
 69                     conditionB.await();
 70                 }
 71 
 72                 conditionC.signal();
 73                 flag = 3;
 74 
 75                 if (i <= 99) {
 76                     System.out.println(Thread.currentThread().getName() + ":" + i);
 77                     i++;
 78 
 79                 } else {
 80                     break;
 81                 }
 82             } catch (InterruptedException e) {
 83                 e.printStackTrace();
 84             } finally {
 85                 lock.unlock();
 86             }
 87         }
 88     }
 89 
 90     // 同理
 91     public void loopC() {
 92         while (true) {
 93             lock.lock();
 94 
 95             try {
 96                 while (flag != 3) {
 97                     conditionC.await();
 98                 }
 99 
100                 conditionA.signal();
101                 flag = 1;
102 
103                 if (i <= 99) {
104                     System.out.println(Thread.currentThread().getName() + ":" + i);
105                     i++;
106 
107                 } else {
108                     break;
109                 }
110             } catch (InterruptedException e) {
111                 e.printStackTrace();
112             } finally {
113                 lock.unlock();
114             }
115         }
116     }
117 }

三个线程交替打印

4、三个线程定制化打印问题

　　开启 3 个线程，要求打印输出为 (A*3B*5C*7) * n。
　　思想同理：接力棒A，交给B，B交给C，C交给A。有上一个问题对lock的使用，这个问题不难给出答案。
　　代码示例：定制化打印

  1 public class Main {
  2 
  3     public static void main(String[] args) {
  4         Num num = new Num();
  5 
  6         new Thread(() -> {
  7             for (int i = 0; i < 10; i++) {
  8                 num.loopA();
  9             }
 10         }, "A").start();
 11 
 12         new Thread(() -> {
 13             for (int i = 0; i < 10; i++) {
 14                 num.loopB();
 15             }
 16         }, "B").start();
 17 
 18         new Thread(() -> {
 19             for (int i = 0; i < 10; i++) {
 20                 num.loopC();
 21             }
 22         }, "C").start();
 23     }
 24 }
 25 
 26 class Num {
 27     // 当前正在执行的线程的标记
 28     private int flag = 1;
 29     final private Lock lock = new ReentrantLock();
 30     final Condition conditionA = lock.newCondition();
 31     final Condition conditionB = lock.newCondition();
 32     final Condition conditionC = lock.newCondition();
 33 
 34     public void loopA() {
 35         lock.lock();
 36 
 37         try {
 38             // 线程A判断是不是该自己打印
 39             while (flag != 1) {
 40                 conditionA.await();
 41             }
 42             // 唤醒B
 43             conditionB.signal();
 44             flag = 2;
 45 
 46             // 将线程A的名称打印 3 遍
 47             for (int i = 0; i < 3; i++) {
 48                 System.out.println(Thread.currentThread().getName());
 49             }
 50         } catch (InterruptedException e) {
 51             e.printStackTrace();
 52         } finally {
 53             lock.unlock();
 54         }
 55     }
 56 
 57     // 同理
 58     public void loopB() {
 59         lock.lock();
 60 
 61         try {
 62             while (flag != 2) {
 63                 conditionB.await();
 64             }
 65 
 66             conditionC.signal();
 67             flag = 3;
 68 
 69             // 将线程B的名称打印 5 遍
 70             for (int i = 0; i < 5; i++) {
 71                 System.out.println(Thread.currentThread().getName());
 72             }
 73         } catch (InterruptedException e) {
 74             e.printStackTrace();
 75         } finally {
 76             lock.unlock();
 77         }
 78     }
 79 
 80     // 同理
 81     public void loopC() {
 82         lock.lock();
 83 
 84         try {
 85             while (flag != 3) {
 86                 conditionC.await();
 87             }
 88 
 89             conditionA.signal();
 90             flag = 1;
 91 
 92             // 将线程C的名称打印 7 遍
 93             for (int i = 0; i < 7; i++) {
 94                 System.out.println(Thread.currentThread().getName());
 95             }
 96         } catch (InterruptedException e) {
 97             e.printStackTrace();
 98         } finally {
 99             lock.unlock();
100         }
101     }
102 }
103 
104 // 结果
105 (AAABBBBBCCCCCCC)*10

定制化打印

　　这种定制化打印理解后，如果想要(ABC)*10，或其他形式的输出。相信修改哪里的参数应该很清楚了。

二、生产者与消费者

1、介绍

　　生产者：不停生产产品，然后交给店员。
　　消费者：不停消费产品，从店员处消费。
　　店员：一次性持有的产品数量固定。

　　代码示例：生产者生产20个，消费者消费20个，店员持有10个产品满。

 1 // 不写注释也能看懂的代码
 2 // 店员
 3 public class Clerk {
 4     // 产品数量
 5     private int product = 0;
 6 
 7     // 进货
 8     public synchronized void get() {
 9         if (product >= 10) {
10             System.out.println("产品已满！");
11         } else {
12             System.out.println(Thread.currentThread().getName() + " : " + ++product);
13         }
14     }
15 
16     // 卖货
17     public synchronized void sale() {
18         if (product <= 0) {
19             System.out.println("产品缺货！");
20         } else {
21             System.out.println(Thread.currentThread().getName() + " : " + --product);
22         }
23     }
24 }
25 
26 // 生产者
27 class Producer implements Runnable {
28     private final Clerk clerk;
29 
30     public Producer(Clerk clerk) {
31         this.clerk = clerk;
32     }
33 
34     @Override
35     public void run() {
36         for (int i = 0; i < 20; i++) {
37 //            try {
38 //                Thread.sleep(200);
39 //            } catch (InterruptedException e) {
40 //            }
41 
42             clerk.get();
43         }
44     }
45 }
46 
47 // 消费者
48 class Consumer implements Runnable {
49     private final Clerk clerk;
50 
51     public Consumer(Clerk clerk) {
52         this.clerk = clerk;
53     }
54 
55     @Override
56     public void run() {
57         for (int i = 0; i < 20; i++) {
58             clerk.sale();
59         }
60     }
61 }

 1 // 测试类
 2 public class Main {
 3     public static void main(String[] args) {
 4         Clerk clerk = new Clerk();
 5         Producer producer = new Producer(clerk);
 6         Consumer consumer = new Consumer(clerk);
 7         
 8         // 分别开启了一个生产者A 和 一个消费者B
 9         new Thread(producer, "生产者A").start();
10         new Thread(consumer, "消费者B").start();
11     }
12 }
13 
14 // 可能的一种结果
15 生产者A : 1
16 消费者B : 0
17 产品缺货！
18 产品缺货！
19 产品缺货！
20 产品缺货！
21 产品缺货！
22 产品缺货！
23 产品缺货！
24 产品缺货！
25 产品缺货！
26 产品缺货！
27 产品缺货！
28 产品缺货！
29 产品缺货！
30 产品缺货！
31 产品缺货！
32 产品缺货！
33 产品缺货！
34 产品缺货！
35 产品缺货！
36 生产者A : 1
37 生产者A : 2
38 生产者A : 3
39 生产者A : 4
40 生产者A : 5
41 生产者A : 6
42 生产者A : 7
43 生产者A : 8
44 生产者A : 9
45 生产者A : 10
46 产品已满！
47 产品已满！
48 产品已满！
49 产品已满！
50 产品已满！
51 产品已满！
52 产品已满！
53 产品已满！
54 产品已满！

　　理解：两个线程的共享变量是 product；两个线程共同竞争的锁，同步方法默认是this，指 clerk。
　　这里没有使用等待唤醒机制。在生产满时，若抢到锁，依然会一直生产；在消费空时，若抢到锁，依然会一直消费。
　　图解：

2、等待唤醒

　　上述结果并不是想要的。希望产品满时，等待消费者消费一个时，再生产；而产品空时，等待生产者生产一个时，再消费。用等待唤醒机制改进：

 1 public class Clerk {
 2     // 产品数量
 3     private int product = 0;
 4 
 5     // 进货
 6     public synchronized void get() {
 7         if (product >= 10) {
 8             System.out.println("产品已满！");
 9 
10             // 满了就等待.就不生产
11             try {
12                 this.wait();
13             } catch (InterruptedException e) {
14                 e.printStackTrace();
15             }
16         } else {
17             System.out.println(Thread.currentThread().getName() + " : " + ++product);
18             // 通知消费者有货,可以消费
19             this.notify();
20         }
21     }
22 
23     // 卖货
24     public synchronized void sale() {
25         if (product <= 0) {
26             System.out.println("产品缺货！");
27             
28             // 缺货就等待
29             try {
30                 this.wait();
31             } catch (InterruptedException e) {
32                 e.printStackTrace();
33             }
34         } else {
35             System.out.println(Thread.currentThread().getName() + " : " + --product);
36             // 通知生产者,可以生产
37             this.notify();
38         }
39     }
40 }
41 
42 // 可能的一种结果
43 生产者A : 1
44 消费者B : 0
45 产品缺货！
46 生产者A : 1
47 生产者A : 2
48 消费者B : 1
49 消费者B : 0
50 产品缺货！
51 生产者A : 1
52 消费者B : 0
53 产品缺货！
54 生产者A : 1
55 消费者B : 0
56 产品缺货！
57 生产者A : 1
58 消费者B : 0
59 产品缺货！
60 生产者A : 1
61 生产者A : 2
62 消费者B : 1
63 消费者B : 0
64 产品缺货！
65 生产者A : 1
66 消费者B : 0
67 产品缺货！
68 生产者A : 1
69 生产者A : 2
70 生产者A : 3
71 生产者A : 4
72 消费者B : 3
73 消费者B : 2
74 消费者B : 1
75 消费者B : 0
76 生产者A : 1
77 生产者A : 2
78 生产者A : 3
79 生产者A : 4
80 生产者A : 5
81 生产者A : 6
82 生产者A : 7

等待唤醒

　　问题：如果将店员持有 10 个满改成持有 1 个满，如下：

1 if (product >= 1) {}
2 
3 // 结果
4 …………省略前面的
5 生产者A : 1
6 产品已满！
7 消费者B : 0
8 产品缺货！

　　运行的结果没问题，但是程序停不下来。分析运行结果有利于更好的理解多线程编程。结合打印结果，不难得出：最后一次，消费者B缺货，等待，而生产者A执行完毕，已无法再唤醒消费者B。
　　解决：把 else 打开即可。
　　理解：其实不难理解它的现实语义。生产者A判断产品满，就等待，不满，就生产。消费者B判断产品空，就等待，不空，就消费。

3、虚假唤醒问题

　　问题：在上述代码基础上，如果有多个生产者，多个消费者，会出现负数。

 1 public class Main {
 2     public static void main(String[] args) {
 3         Clerk clerk = new Clerk();
 4         Producer producer = new Producer(clerk);
 5         Consumer consumer = new Consumer(clerk);
 6         new Thread(producer, "生产者A").start();
 7         new Thread(consumer, "消费者B").start();
 8         
 9         // 新增一个生产者和一个消费者
10         new Thread(producer, "生产者C").start();
11         new Thread(consumer, "消费者D").start();
12     }
13 }
14 
15 // 把上述 this.notify() 都改为 this.notifyAll();

　　原因：消费者B抢到锁，product == 0，等待；消费者D抢到锁，product == 0，等待。然后，生产者A抢到锁，生产一个，product == 1。就会唤醒两个消费者，同时消费，就出现0、-1。这就是虚假唤醒问题。
　　解决：把 if 改为 while 即可。

　　参考文档：https://www.matools.com/api/java8

4、用lock实现

　　代码示例：完整用lock实现的生产者与消费者

 1 public class Clerk {
 2     // 产品数量
 3     private int product = 0;
 4     final private Lock lock = new ReentrantLock();
 5     final Condition condition = lock.newCondition();
 6 
 7     // 进货
 8     public void get() {
 9         lock.lock();
10         try {
11             while (product >= 1) {
12                 System.out.println("产品已满！");
13 
14                 try {
15                     condition.await();
16                 } catch (InterruptedException e) {
17                     e.printStackTrace();
18                 }
19             }
20 
21             System.out.println(Thread.currentThread().getName() + " : " + ++product);
22             condition.signalAll();
23         } finally {
24             lock.unlock();
25         }
26     }
27 
28     // 卖货
29     public void sale() {
30         lock.lock();
31         try {
32             while (product <= 0) {
33                 System.out.println("产品缺货！");
34 
35                 try {
36                     condition.await();
37                 } catch (InterruptedException e) {
38                     e.printStackTrace();
39                 }
40             }
41 
42             System.out.println(Thread.currentThread().getName() + " : " + --product);
43             condition.signalAll();
44         } finally {
45             lock.unlock();
46         }
47     }
48 }
49 
50 // 生产者
51 class Producer implements Runnable {
52     private final Clerk clerk;
53 
54     public Producer(Clerk clerk) {
55         this.clerk = clerk;
56     }
57 
58     @Override
59     public void run() {
60         for (int i = 0; i < 20; i++) {
61             try {
62                 Thread.sleep(200);
63             } catch (InterruptedException e) {
64             }
65 
66             clerk.get();
67         }
68     }
69 }
70 
71 // 消费者
72 class Consumer implements Runnable {
73     private final Clerk clerk;
74 
75     public Consumer(Clerk clerk) {
76         this.clerk = clerk;
77     }
78 
79     @Override
80     public void run() {
81         for (int i = 0; i < 20; i++) {
82             clerk.sale();
83         }
84     }
85 }

 1 // 测试类
 2 public class Main {
 3     public static void main(String[] args) {
 4         Clerk clerk = new Clerk();
 5         Producer producer = new Producer(clerk);
 6         Consumer consumer = new Consumer(clerk);
 7         new Thread(producer, "生产者A").start();
 8         new Thread(consumer, "消费者B").start();
 9 
10         new Thread(producer, "生产者C").start();
11         new Thread(consumer, "消费者D").start();
12     }
13 }