母鸡下蛋实例：多线程通信生产者和消费者wait/notify和condition/await/signal条件队列

多线程通信一直是高频面试考点，有些面试官可能要求现场手写生产者/消费者代码来考察多线程的功底，今天我们以实际生活中母鸡下蛋案例用代码剖析下实现过程。母鸡在鸡窝下蛋了，叫练从鸡窝里把鸡蛋拿出来这个过程，母鸡在鸡窝下蛋，是生产者，叫练捡出鸡蛋，叫练是消费者，一进一出就是线程中的生产者和消费者模型了，鸡窝是放鸡蛋容器。现实中还有很多这样的案例，如医院叫号。下面我们画个图表示下。
image.png

  1. package com.duyang.thread.basic.waitLock.demo;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * @author ：jiaolian
  8.  * @date ：Created in 2020-12-30 16:18
  9.  * @description：母鸡下蛋：一对一生产者和消费者
  10.  * @modified By：
  11.  * 公众号:叫练
  12.  */
  13. public class SingleNotifyWait {
  15.     //装鸡蛋的容器
  16.     private static class EggsList {
  17.         private static final List<String> LIST = new ArrayList();
  18.     }
  20.     //生产者：母鸡实体类
  21.     private static class HEN {
  22.         private String name;
  24.         public HEN(String name) {
  25.             this.name = name;
  26.         }
  28.         //下蛋
  29.         public void proEggs() throws InterruptedException {
  30.             synchronized (EggsList.class) {
  31.                 if (EggsList.LIST.size() == 1) {
  32.                     EggsList.class.wait();
  33.                 }
  34.                 //容器添加一个蛋
  35.                 EggsList.LIST.add("1");
  36.                 //鸡下蛋需要休息才能继续产蛋
  37.                 Thread.sleep(1000);
  38.                 System.out.println(name+":下了一个鸡蛋！");
  39.                 //通知叫练捡蛋
  40.                 EggsList.class.notify();
  41.             }
  42.         }
  43.     }
  45.     //人对象
  46.     private static class Person {
  47.         private String name;
  49.         public Person(String name) {
  50.             this.name = name;
  51.         }
  52.         //取蛋
  53.         public void getEggs() throws InterruptedException {
  54.             synchronized (EggsList.class) {
  55.                 if (EggsList.LIST.size() == 0) {
  56.                     EggsList.class.wait();
  57.                 }
  58.                 Thread.sleep(500);
  59.                 EggsList.LIST.remove(0);
  60.                 System.out.println(name+":从容器中捡出一个鸡蛋");
  61.                 //通知叫练捡蛋
  62.                 EggsList.class.notify();
  63.             }
  64.         }
  65.     }
  67.     public static void main(String[] args) {
  68.         //创造一个人和一只鸡
  69.         HEN hen = new HEN("小黑");
  70.         Person person = new Person("叫练");
  71.         //创建线程执行下蛋和捡蛋的过程；
  72.         new Thread(()->{
  73.             try {
  74.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  75.                     hen.proEggs();
  76.                 }
  77.             } catch (InterruptedException e) {
  78.                 e.printStackTrace();
  79.             }
  80.         }).start();
  81.         //叫练捡鸡蛋的过程！
  82.         new Thread(()->{
  83.             try {
  84.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  85.                     person.getEggs();
  86.                 }
  87.             } catch (InterruptedException e) {
  88.                 e.printStackTrace();
  89.             }
  90.         }).start();
  91.     }
  92. }

如上面代码，我们定义EggsList类来装鸡蛋，HEN类表示母鸡，Person类表示人。在主函数中创建母鸡对象“小黑”，人对象“叫练”， 创建两个线程分别执行下蛋和捡蛋的过程。代码中定义鸡窝中最多只能装一个鸡蛋（当然可以定义多个）。详细过程：“小黑”母鸡线程和“叫练”线程线程竞争锁，如果“小黑”母鸡线程先获取锁，发现EggsList鸡蛋的个数大于0，表示有鸡蛋，那就调用wait等待并释放锁给“叫练”线程，如果没有鸡蛋，就调用EggsList.LIST.add(“1”)表示生产了一个鸡蛋并通知“叫练”来取鸡蛋并释放锁让“叫练”线程获取锁。“叫练”线程调用getEggs()方法获取锁后发现，如果鸡窝中并没有鸡蛋就调用wait等待并释放锁通知“小黑”线程获取锁去下蛋，如果有鸡蛋，说明“小黑”已经下蛋了，就把鸡蛋取走，因为鸡窝没有鸡蛋了，所以最后也要通知调用notify()方法通知“小黑”去下蛋，我们观察程序的执行结果如下图。两个线程是死循环程序会一直执行下去，下蛋和捡蛋的过程中用到的锁的是EggsList类的class，“小黑”和“叫练”竞争的都是统一把锁，所以这个是同步的。这就是母鸡“小黑”和“叫练”沟通的过程。
image.png
神马？？？鸡和人能沟通！！
image.png

  1. package com.duyang.thread.basic.waitLock.demo;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.locks.Condition;
  6. import java.util.concurrent.locks.Lock;
  7. import java.util.concurrent.locks.ReentrantLock;
  9. /**
  10.  * @author ：jiaolian
  11.  * @date ：Created in 2020-12-30 16:18
  12.  * @description：母鸡下蛋：一对一生产者和消费者 条件队列
  13.  * @modified By：
  14.  * 公众号:叫练
  15.  */
  16. public class SingleCondition {
  18.     private static Lock lock = new ReentrantLock();
  19.     //条件队列
  20.     private static Condition condition = lock.newCondition();
  22.     //装鸡蛋的容器
  23.     private static class EggsList {
  24.         private static final List<String> LIST = new ArrayList();
  25.     }
  27.     //生产者：母鸡实体类
  28.     private static class HEN {
  29.         private String name;
  31.         public HEN(String name) {
  32.             this.name = name;
  33.         }
  35.         //下蛋
  36.         public void proEggs() {
  37.             try {
  38.                 lock.lock();
  39.                 if (EggsList.LIST.size() == 1) {
  40.                     condition.await();
  41.                 }
  42.                 //容器添加一个蛋
  43.                 EggsList.LIST.add("1");
  44.                 //鸡下蛋需要休息才能继续产蛋
  45.                 Thread.sleep(1000);
  46.                 System.out.println(name+":下了一个鸡蛋！");
  47.                 //通知叫练捡蛋
  48.                 condition.signal();
  49.             } catch (Exception e) {
  50.                 e.printStackTrace();
  51.             } finally {
  52.                 lock.unlock();
  53.             }
  54.         }
  55.     }
  57.     //人对象
  58.     private static class Person {
  59.         private String name;
  61.         public Person(String name) {
  62.             this.name = name;
  63.         }
  64.         //取蛋
  65.         public void getEggs() {
  66.             try {
  67.                 lock.lock();
  68.                 if (EggsList.LIST.size() == 0) {
  69.                     condition.await();
  70.                 }
  71.                 Thread.sleep(500);
  72.                 EggsList.LIST.remove(0);
  73.                 System.out.println(name+":从容器中捡出一个鸡蛋");
  74.                 //通知叫练捡蛋
  75.                 condition.signal();
  76.             } catch (Exception e) {
  77.                 e.printStackTrace();
  78.             } finally {
  79.                 lock.unlock();
  80.             }
  81.         }
  82.     }
  84.     public static void main(String[] args) {
  85.         //创造一个人和一只鸡
  86.         HEN hen = new HEN("小黑");
  87.         Person person = new Person("叫练");
  88.         //创建线程执行下蛋和捡蛋的过程；
  89.         new Thread(()->{
  90.             for (int i=0; i<Integer.MAX_VALUE;i++) {
  91.                 hen.proEggs();
  92.             }
  93.         }).start();
  94.         //叫练捡鸡蛋的过程！
  95.         new Thread(()->{
  96.             for (int i=0; i<Integer.MAX_VALUE;i++) {
  97.                 person.getEggs();
  98.             }
  99.         }).start();
  100.     }
  101. }

如上面代码，只是将synchronized换成了Lock，程序运行的结果和上面的一致，wait/notify换成了AQS的条件队列Condition来控制线程之间的通信。Lock需要手动加锁lock.lock()，解锁lock.unlock()的步骤放在finally代码块保证锁始终能被释放。await底层是unsafe.park(false,0)调用C++代码实现。

  1. package com.duyang.thread.basic.waitLock.demo;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * @author ：jiaolian
  8.  * @date ：Created in 2020-12-30 16:18
  9.  * @description：母鸡下蛋：多对多生产者和消费者
  10.  * @modified By：
  11.  * 公众号:叫练
  12.  */
  13. public class MultNotifyWait {
  15.     //装鸡蛋的容器
  16.     private static class EggsList {
  17.         private static final List<String> LIST = new ArrayList();
  18.     }
  20.     //生产者：母鸡实体类
  21.     private static class HEN {
  22.         private String name;
  24.         public HEN(String name) {
  25.             this.name = name;
  26.         }
  28.         //下蛋
  29.         public void proEggs() throws InterruptedException {
  30.             synchronized (EggsList.class) {
  31.                 while (EggsList.LIST.size() >= 10) {
  32.                     EggsList.class.wait();
  33.                 }
  34.                 //容器添加一个蛋
  35.                 EggsList.LIST.add("1");
  36.                 //鸡下蛋需要休息才能继续产蛋
  37.                 Thread.sleep(1000);
  38.                 System.out.println(name+":下了一个鸡蛋！共有"+EggsList.LIST.size()+"个蛋");
  39.                 //通知叫练捡蛋
  40.                 EggsList.class.notify();
  41.             }
  42.         }
  43.     }
  45.     //人对象
  46.     private static class Person {
  47.         private String name;
  49.         public Person(String name) {
  50.             this.name = name;
  51.         }
  52.         //取蛋
  53.         public void getEggs() throws InterruptedException {
  54.             synchronized (EggsList.class) {
  55.                 while (EggsList.LIST.size() == 0) {
  56.                     EggsList.class.wait();
  57.                 }
  58.                 Thread.sleep(500);
  59.                 EggsList.LIST.remove(0);
  60.                 System.out.println(name+":从容器中捡出一个鸡蛋！还剩"+EggsList.LIST.size()+"个蛋");
  61.                 //通知叫练捡蛋
  62.                 EggsList.class.notify();
  63.             }
  64.         }
  65.     }
  67.     public static void main(String[] args) {
  68.         //创造一个人和一只鸡
  69.         HEN hen1 = new HEN("小黑");
  70.         HEN hen2 = new HEN("小黄");
  71.         Person jiaolian = new Person("叫练");
  72.         Person wife = new Person("叫练媳妇");
  73.         //创建线程执行下蛋和捡蛋的过程；
  74.         new Thread(()->{
  75.             try {
  76.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  77.                     hen1.proEggs();
  78.                     Thread.sleep(50);
  79.                 }
  80.             } catch (InterruptedException e) {
  81.                 e.printStackTrace();
  82.             }
  83.         }).start();
  84.         new Thread(()->{
  85.             try {
  86.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  87.                     hen2.proEggs();
  88.                     Thread.sleep(50);
  89.                 }
  90.             } catch (InterruptedException e) {
  91.                 e.printStackTrace();
  92.             }
  93.         }).start();
  94.         //叫练捡鸡蛋的线程！
  95.         new Thread(()->{
  96.             try {
  97.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  98.                     jiaolian.getEggs();
  99.                 }
  100.             } catch (InterruptedException e) {
  101.                 e.printStackTrace();
  102.             }
  103.         }).start();
  104.         //叫练媳妇捡鸡蛋的线程！
  105.         new Thread(()->{
  106.             try {
  107.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  108.                     wife.getEggs();
  109.                 }
  110.             } catch (InterruptedException e) {
  111.                 e.printStackTrace();
  112.             }
  113.         }).start();
  114.     }
  115. }

如上面代码，参照一对一生产和消费中wait/notify代码做了一些修改，创建了两个母鸡线程“小黑”，“小黄”，两个捡鸡蛋的线程“叫练”，“叫练媳妇”，执行结果是同步的，实现了多对多的生产和消费，如下图所示。有如下几点需要注意的地方：

  1. 鸡窝中能容纳最大的鸡蛋是10个。
  2. 下蛋proEggs（）方法中判断鸡蛋数量是否大于等于10个使用的是while循环，wait收到通知，唤醒当前线程，需要重新判断一次，避免程序出现逻辑问题，这里不能用if，如果用if，程序可能出现EggsList有超过10以上鸡蛋的情况。这是这道程序中容易出现错误的地方，也是经常会被问到的点，值得重点探究下。
  3. 多对多的生产者和消费者。

image.png

  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.concurrent.locks.Condition;
  5. import java.util.concurrent.locks.Lock;
  6. import java.util.concurrent.locks.ReentrantLock;
  8. /**
  9.  * @author ：jiaolian
  10.  * @date ：Created in 2020-12-30 16:18
  11.  * @description：母鸡下蛋：多对多生产者和消费者 条件队列
  12.  * @modified By：
  13.  * 公众号:叫练
  14.  */
  15. public class MultCondition {
  17.     private static Lock lock = new ReentrantLock();
  18.     //条件队列
  19.     private static Condition condition = lock.newCondition();
  21.     //装鸡蛋的容器
  22.     private static class EggsList {
  23.         private static final List<String> LIST = new ArrayList();
  24.     }
  26.     //生产者：母鸡实体类
  27.     private static class HEN {
  28.         private String name;
  30.         public HEN(String name) {
  31.             this.name = name;
  32.         }
  34.         //下蛋
  35.         public void proEggs() {
  36.             try {
  37.                 lock.lock();
  38.                 while (EggsList.LIST.size() >= 10) {
  39.                     condition.await();
  40.                 }
  41.                 //容器添加一个蛋
  42.                 EggsList.LIST.add("1");
  43.                 //鸡下蛋需要休息才能继续产蛋
  44.                 Thread.sleep(1000);
  45.                 System.out.println(name+":下了一个鸡蛋！共有"+ EggsList.LIST.size()+"个蛋");
  46.                 //通知叫练/叫练媳妇捡蛋
  47.                 condition.signalAll();
  48.             } catch (Exception e) {
  49.                 e.printStackTrace();
  50.             } finally {
  51.                 lock.unlock();
  52.             }
  53.         }
  54.     }
  56.     //人对象
  57.     private static class Person {
  58.         private String name;
  60.         public Person(String name) {
  61.             this.name = name;
  62.         }
  63.         //取蛋
  64.         public void getEggs() throws InterruptedException {
  65.             try {
  66.                 lock.lock();
  67.                 while (EggsList.LIST.size() == 0) {
  68.                     condition.await();
  69.                 }
  70.                 Thread.sleep(500);
  71.                 EggsList.LIST.remove(0);
  72.                 System.out.println(name+":从容器中捡出一个鸡蛋！还剩"+ EggsList.LIST.size()+"个蛋");
  73.                 //通知叫练捡蛋
  74.                 condition.signalAll();
  75.             } catch (Exception e) {
  76.                 e.printStackTrace();
  77.             } finally {
  78.                 lock.unlock();
  79.             }
  80.         }
  81.     }
  83.     public static void main(String[] args) {
  84.         //创造一个人和一只鸡
  85.         HEN hen1 = new HEN("小黑");
  86.         HEN hen2 = new HEN("小黄");
  87.         Person jiaolian = new Person("叫练");
  88.         Person wife = new Person("叫练媳妇");
  89.         //创建线程执行下蛋和捡蛋的过程；
  90.         new Thread(()->{
  91.             try {
  92.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  93.                     hen1.proEggs();
  94.                     Thread.sleep(50);
  95.                 }
  96.             } catch (InterruptedException e) {
  97.                 e.printStackTrace();
  98.             }
  99.         }).start();
  100.         new Thread(()->{
  101.             try {
  102.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  103.                     hen2.proEggs();
  104.                     Thread.sleep(50);
  105.                 }
  106.             } catch (InterruptedException e) {
  107.                 e.printStackTrace();
  108.             }
  109.         }).start();
  110.         //叫练捡鸡蛋的线程！
  111.         new Thread(()->{
  112.             try {
  113.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  114.                     jiaolian.getEggs();
  115.                 }
  116.             } catch (InterruptedException e) {
  117.                 e.printStackTrace();
  118.             }
  119.         }).start();
  120.         //叫练媳妇捡鸡蛋的线程！
  121.         new Thread(()->{
  122.             try {
  123.                 for (int i=0; i<Integer.MAX_VALUE;i++) {
  124.                     wife.getEggs();
  125.                 }
  126.             } catch (InterruptedException e) {
  127.                 e.printStackTrace();
  128.             }
  129.         }).start();
  130.     }
  131. }

如上面代码，只是将synchronized换成了Lock，程序运行的结果和上面的一致，下面我们比较下Lock和synchronized的异同。这个问题也是面试中会经常问到的！

Lock和synchronized都能让多线程同步。主要异同点表现如下！

  1. 锁性质：Lock乐观锁是非阻塞的，底层是依赖cas+volatile实现，synchronized悲观锁是阻塞的，需要上下文切换。实现思想不一样。
  2. 功能细节上：Lock需要手动加解锁，synchronized自动加解锁。Lock还提供颗粒度更细的功能，比如tryLock等。
  3. 线程通信：Lock提供Condition条件队列，一把锁可以对应多个条件队列，对线程控制更细腻。synchronized只能对应一个wait/notify。

主要就这些吧，如果对synchronized，volatile，cas关键字不太了解的童鞋，可以看看我之前的文章，有很详细的案例和说明。

今天用生活中的例子转化成代码，实现了两种多线程中消费者/生产者模式，给您的建议就是需要把代码敲一遍，如果认真执行了一遍代码应该能看明白，喜欢的请点赞加关注哦。我是叫练【公众号】，边叫边练。
image.png

版权声明：本文为jiaolian原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jiaolian/p/14214842.html