母鸡下蛋实例：多线程通信生产者和消费者wait/notify和condition/await/signal条件队列
简介
多线程通信一直是高频面试考点，有些面试官可能要求现场手写生产者/消费者代码来考察多线程的功底，今天我们以实际生活中母鸡下蛋案例用代码剖析下实现过程。母鸡在鸡窝下蛋了，叫练从鸡窝里把鸡蛋拿出来这个过程，母鸡在鸡窝下蛋，是生产者，叫练捡出鸡蛋，叫练是消费者，一进一出就是线程中的生产者和消费者模型了，鸡窝是放鸡蛋容器。现实中还有很多这样的案例，如医院叫号。下面我们画个图表示下。
一对一生产和消费：一只母鸡和叫练
wait/notify
package com.duyang.thread.basic.waitLock.demo;
import java.util.ArrayList;
import java.util.List;
/**
* @author ：jiaolian
* @date ：Created in 2020-12-30 16:18
* @description：母鸡下蛋：一对一生产者和消费者
* @modified By：
* 公众号:叫练
*/
public class SingleNotifyWait {
//装鸡蛋的容器
private static class EggsList {
private static final List<String> LIST = new ArrayList();
}
//生产者：母鸡实体类
private static class HEN {
private String name;
public HEN(String name) {
this.name = name;
}
//下蛋
public void proEggs() throws InterruptedException {
synchronized (EggsList.class) {
if (EggsList.LIST.size() == 1) {
EggsList.class.wait();
}
//容器添加一个蛋
EggsList.LIST.add("1");
//鸡下蛋需要休息才能继续产蛋
Thread.sleep(1000);
System.out.println(name+":下了一个鸡蛋！");
//通知叫练捡蛋
EggsList.class.notify();
}
}
}
//人对象
private static class Person {
private String name;
public Person(String name) {
this.name = name;
}
//取蛋
public void getEggs() throws InterruptedException {
synchronized (EggsList.class) {
if (EggsList.LIST.size() == 0) {
EggsList.class.wait();
}
Thread.sleep(500);
EggsList.LIST.remove(0);
System.out.println(name+":从容器中捡出一个鸡蛋");
//通知叫练捡蛋
EggsList.class.notify();
}
}
}
public static void main(String[] args) {
//创造一个人和一只鸡
HEN hen = new HEN("小黑");
Person person = new Person("叫练");
//创建线程执行下蛋和捡蛋的过程；
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
hen.proEggs();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
//叫练捡鸡蛋的过程！
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
person.getEggs();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
如上面代码，我们定义EggsList类来装鸡蛋，HEN类表示母鸡，Person类表示人。在主函数中创建母鸡对象“小黑”，人对象“叫练”， 创建两个线程分别执行下蛋和捡蛋的过程。代码中定义鸡窝中最多只能装一个鸡蛋（当然可以定义多个）。详细过程：“小黑”母鸡线程和“叫练”线程线程竞争锁，如果“小黑”母鸡线程先获取锁，发现EggsList鸡蛋的个数大于0，表示有鸡蛋，那就调用wait等待并释放锁给“叫练”线程，如果没有鸡蛋，就调用EggsList.LIST.add("1")表示生产了一个鸡蛋并通知“叫练”来取鸡蛋并释放锁让“叫练”线程获取锁。“叫练”线程调用getEggs()方法获取锁后发现，如果鸡窝中并没有鸡蛋就调用wait等待并释放锁通知“小黑”线程获取锁去下蛋，如果有鸡蛋，说明“小黑”已经下蛋了，就把鸡蛋取走，因为鸡窝没有鸡蛋了，所以最后也要通知调用notify()方法通知“小黑”去下蛋，我们观察程序的执行结果如下图。两个线程是死循环程序会一直执行下去，下蛋和捡蛋的过程中用到的锁的是EggsList类的class，“小黑”和“叫练”竞争的都是统一把锁，所以这个是同步的。这就是母鸡“小黑”和“叫练”沟通的过程。
神马？？？鸡和人能沟通！！
Lock条件队列
package com.duyang.thread.basic.waitLock.demo;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author ：jiaolian
* @date ：Created in 2020-12-30 16:18
* @description：母鸡下蛋：一对一生产者和消费者 条件队列
* @modified By：
* 公众号:叫练
*/
public class SingleCondition {
private static Lock lock = new ReentrantLock();
//条件队列
private static Condition condition = lock.newCondition();
//装鸡蛋的容器
private static class EggsList {
private static final List<String> LIST = new ArrayList();
}
//生产者：母鸡实体类
private static class HEN {
private String name;
public HEN(String name) {
this.name = name;
}
//下蛋
public void proEggs() {
try {
lock.lock();
if (EggsList.LIST.size() == 1) {
condition.await();
}
//容器添加一个蛋
EggsList.LIST.add("1");
//鸡下蛋需要休息才能继续产蛋
Thread.sleep(1000);
System.out.println(name+":下了一个鸡蛋！");
//通知叫练捡蛋
condition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
//人对象
private static class Person {
private String name;
public Person(String name) {
this.name = name;
}
//取蛋
public void getEggs() {
try {
lock.lock();
if (EggsList.LIST.size() == 0) {
condition.await();
}
Thread.sleep(500);
EggsList.LIST.remove(0);
System.out.println(name+":从容器中捡出一个鸡蛋");
//通知叫练捡蛋
condition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
//创造一个人和一只鸡
HEN hen = new HEN("小黑");
Person person = new Person("叫练");
//创建线程执行下蛋和捡蛋的过程；
new Thread(()->{
for (int i=0; i<Integer.MAX_VALUE;i++) {
hen.proEggs();
}
}).start();
//叫练捡鸡蛋的过程！
new Thread(()->{
for (int i=0; i<Integer.MAX_VALUE;i++) {
person.getEggs();
}
}).start();
}
}
如上面代码，只是将synchronized换成了Lock，程序运行的结果和上面的一致，wait/notify换成了AQS的条件队列Condition来控制线程之间的通信。Lock需要手动加锁lock.lock()，解锁lock.unlock()的步骤放在finally代码块保证锁始终能被释放。await底层是unsafe.park(false,0)调用C++代码实现。
多对多生产和消费：2只母鸡和叫练/叫练媳妇
wait/notifyAll
package com.duyang.thread.basic.waitLock.demo;
import java.util.ArrayList;
import java.util.List;
/**
* @author ：jiaolian
* @date ：Created in 2020-12-30 16:18
* @description：母鸡下蛋：多对多生产者和消费者
* @modified By：
* 公众号:叫练
*/
public class MultNotifyWait {
//装鸡蛋的容器
private static class EggsList {
private static final List<String> LIST = new ArrayList();
}
//生产者：母鸡实体类
private static class HEN {
private String name;
public HEN(String name) {
this.name = name;
}
//下蛋
public void proEggs() throws InterruptedException {
synchronized (EggsList.class) {
while (EggsList.LIST.size() >= 10) {
EggsList.class.wait();
}
//容器添加一个蛋
EggsList.LIST.add("1");
//鸡下蛋需要休息才能继续产蛋
Thread.sleep(1000);
System.out.println(name+":下了一个鸡蛋！共有"+EggsList.LIST.size()+"个蛋");
//通知叫练捡蛋
EggsList.class.notify();
}
}
}
//人对象
private static class Person {
private String name;
public Person(String name) {
this.name = name;
}
//取蛋
public void getEggs() throws InterruptedException {
synchronized (EggsList.class) {
while (EggsList.LIST.size() == 0) {
EggsList.class.wait();
}
Thread.sleep(500);
EggsList.LIST.remove(0);
System.out.println(name+":从容器中捡出一个鸡蛋！还剩"+EggsList.LIST.size()+"个蛋");
//通知叫练捡蛋
EggsList.class.notify();
}
}
}
public static void main(String[] args) {
//创造一个人和一只鸡
HEN hen1 = new HEN("小黑");
HEN hen2 = new HEN("小黄");
Person jiaolian = new Person("叫练");
Person wife = new Person("叫练媳妇");
//创建线程执行下蛋和捡蛋的过程；
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
hen1.proEggs();
Thread.sleep(50);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
hen2.proEggs();
Thread.sleep(50);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
//叫练捡鸡蛋的线程！
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
jiaolian.getEggs();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
//叫练媳妇捡鸡蛋的线程！
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
wife.getEggs();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
如上面代码，参照一对一生产和消费中wait/notify代码做了一些修改，创建了两个母鸡线程“小黑”，“小黄”，两个捡鸡蛋的线程“叫练”，“叫练媳妇”，执行结果是同步的，实现了多对多的生产和消费，如下图所示。有如下几点需要注意的地方：
- 鸡窝中能容纳最大的鸡蛋是10个。
- 下蛋proEggs（）方法中判断鸡蛋数量是否大于等于10个使用的是while循环，wait收到通知，唤醒当前线程，需要重新判断一次，避免程序出现逻辑问题，这里不能用if，如果用if，程序可能出现EggsList有超过10以上鸡蛋的情况。这是这道程序中容易出现错误的地方，也是经常会被问到的点，值得重点探究下。
- 多对多的生产者和消费者。
Lock条件队列
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author ：jiaolian
* @date ：Created in 2020-12-30 16:18
* @description：母鸡下蛋：多对多生产者和消费者 条件队列
* @modified By：
* 公众号:叫练
*/
public class MultCondition {
private static Lock lock = new ReentrantLock();
//条件队列
private static Condition condition = lock.newCondition();
//装鸡蛋的容器
private static class EggsList {
private static final List<String> LIST = new ArrayList();
}
//生产者：母鸡实体类
private static class HEN {
private String name;
public HEN(String name) {
this.name = name;
}
//下蛋
public void proEggs() {
try {
lock.lock();
while (EggsList.LIST.size() >= 10) {
condition.await();
}
//容器添加一个蛋
EggsList.LIST.add("1");
//鸡下蛋需要休息才能继续产蛋
Thread.sleep(1000);
System.out.println(name+":下了一个鸡蛋！共有"+ EggsList.LIST.size()+"个蛋");
//通知叫练/叫练媳妇捡蛋
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
//人对象
private static class Person {
private String name;
public Person(String name) {
this.name = name;
}
//取蛋
public void getEggs() throws InterruptedException {
try {
lock.lock();
while (EggsList.LIST.size() == 0) {
condition.await();
}
Thread.sleep(500);
EggsList.LIST.remove(0);
System.out.println(name+":从容器中捡出一个鸡蛋！还剩"+ EggsList.LIST.size()+"个蛋");
//通知叫练捡蛋
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
//创造一个人和一只鸡
HEN hen1 = new HEN("小黑");
HEN hen2 = new HEN("小黄");
Person jiaolian = new Person("叫练");
Person wife = new Person("叫练媳妇");
//创建线程执行下蛋和捡蛋的过程；
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
hen1.proEggs();
Thread.sleep(50);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
hen2.proEggs();
Thread.sleep(50);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
//叫练捡鸡蛋的线程！
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
jiaolian.getEggs();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
//叫练媳妇捡鸡蛋的线程！
new Thread(()->{
try {
for (int i=0; i<Integer.MAX_VALUE;i++) {
wife.getEggs();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
如上面代码，只是将synchronized换成了Lock，程序运行的结果和上面的一致，下面我们比较下Lock和synchronized的异同。这个问题也是面试中会经常问到的！
Lock和synchronized比较
Lock和synchronized都能让多线程同步。主要异同点表现如下！
- 锁性质：Lock乐观锁是非阻塞的，底层是依赖cas+volatile实现，synchronized悲观锁是阻塞的，需要上下文切换。实现思想不一样。
- 功能细节上：Lock需要手动加解锁，synchronized自动加解锁。Lock还提供颗粒度更细的功能，比如tryLock等。
- 线程通信：Lock提供Condition条件队列，一把锁可以对应多个条件队列，对线程控制更细腻。synchronized只能对应一个wait/notify。
主要就这些吧，如果对synchronized，volatile，cas关键字不太了解的童鞋，可以看看我之前的文章，有很详细的案例和说明。
总结
今天用生活中的例子转化成代码，实现了两种多线程中消费者/生产者模式，给您的建议就是需要把代码敲一遍，如果认真执行了一遍代码应该能看明白，喜欢的请点赞加关注哦。我是叫练【公众号】，边叫边练。
母鸡下蛋实例：多线程通信生产者和消费者wait/notify和condition/await/signal条件队列的更多相关文章
- JAVA之旅（十五）——多线程的生产者和消费者，停止线程,守护线程,线程的优先级，setPriority设置优先级，yield临时停止
JAVA之旅(十五)--多线程的生产者和消费者,停止线程,守护线程,线程的优先级,setPriority设置优先级,yield临时停止 我们接着多线程讲 一.生产者和消费者 什么是生产者和消费者?我们 ...
- java 22 - 19 多线程之生产者和消费者的代码优化
在之前,是把生产者录入数据和消费者获取数据的所有代码都分别写在各自的类中. 这样不大好 这次把生产者和消费者部分关键代码都写入资源类中: package zl_Thread; public class ...
- java 22 - 16 多线程之生产者和消费者的问题
生产者和消费者问题的描述图 通过上图,我们可以发现: 生产者和消费者使用的都是同一个资源(肉包子) 所以,当使用线程的时候,这两类的锁也是同一把锁(为了避免出现线程安全问题) 例子:学生信息的录入和获 ...
- 多线程中Object的wait()，notify()和Condition的wait()和singal()对锁的关联
通常将共享资源的操作放置在Sysnchronized定义的区域内,这样当其他线程也获取到这个锁时,必须的等待锁被释放时才能进入该区域.Object为任意一个对象,每个对象都存在一个标志位,并具有两个值 ...
- Java：多线程之生产者与消费者
要求:用两个线程模拟存票.售票过程.但要求每存入一张票,就售出一张票,售出后,再存入,直到售完为止. 用到的知识点:线程等待.唤醒.可能的线程中断异常 下面的方式一和方式二采用的是唤醒所有等待的线程, ...
- 【Java多线程通信】syncrhoized下wait()/notify()与ReentrantLock下condition的用法比较
转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/6556925.html 一:syncrhoized使用同一把锁的多个线程用通信实现执行顺序的调度 我们知道,使 ...
- 【多线程】java多线程实现生产者消费者模式
思考问题: 1.为什么用wait()+notify()实现生产者消费者模式? wait()方法可以暂停线程,并释放对象锁 notify()方法可以唤醒需要该对象锁的其他线程,并在执行完后续步骤,到了s ...
- Java多线程之生产者消费者问题<一>：使用synchronized keyword解决生产者消费者问题
今天看了一片博文,讲Java多线程之线程的协作,当中作者用程序实例说明了生产者和消费者问题,但我及其它读者发现程序多跑几次还是会出现死锁,百度搜了下大都数的样例也都存在bug,经过细致研究发现当中的问 ...
- 第44天学习打卡（JUC 线程和进程 并发和并行 Lock锁 生产者和消费者问题 如何判断锁（8锁问题） 集合类不安全）
什么是JUC 1.java.util工具包 包 分类 业务:普通的线程代码 Thread Runnable 没有返回值.效率相比Callable相对较低 2.线程和进程 进程:一个程序.QQ.exe, ...
随机推荐
- Fiddler 4 （过滤器的使用）
1.先找到过滤器并且勾选 2.勾选 并填写要过滤的地址 3.运行 最终效果如下
- Java虚拟机之内存区域
原创文章,转载请标明出处! 目录 一.背景 二.运行时内存区域概述 1.官方描述 2.中文翻译 3.内存区域简述 4.运行时数据区简图 5.运行时数据区详图 三.JVM线程 JVM数据区域与线程关系 ...
- moviepy AudioClip帧处理ValueError: The truth value of array with more than one element is ambiguous
☞ ░ 前往老猿Python博文目录 ░ 一.环境 操作系统:win7 64位 moviepy:1.0.3 numpy:1.19.0 Python:3.7.2 二.应用代码及报错信息 程序代码 if ...
- DokcerFile的添加及如何生成一个自定义镜像mycentos（四）
最近在学习Docker,用commit去生成一个镜像,但是生成后的镜像非常臃肿,所以去学习了一下DockerFile. 前提条件: 已在虚拟机中成功安装Docker 简单的理解可以如下图所示: Doc ...
- hihocoder 1489(微软2017， 数学，模拟)
题目链接:http://hihocoder.com/problemset/problem/1489?sid=1587434 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 ...
- Day5 【Scrum 冲刺博客】
每日会议总结 昨天已完成的工作 方晓莹(PIPIYing) 搭建与后台对接的代理服务器 对接个人中心接口 方子茵(Laa-L):暂无 黄芯悦(Sheaxx) 完善投诉反馈页面 完善车位管理页面 舒雯钰 ...
- javascript常用继承方式.
//原型链继承 function Parent() { this.name = 'per'; } function Child() { this.age = 20; } Child.prototy ...
- 【WC2014】紫荆花之恋（替罪羊重构点分树 & 平衡树）
Description 若带点权.边权的树上一对 \((u, v)\) 为 friend,那么需要满足 \(\text{dist}(u, v) \le r_u + r_v\),其中 \(r_x\) 为 ...
- Nginx安装配置教程
转自https://www.cnblogs.com/zhouxinfei/p/7862285.html nginx概述 nginx是一款自由的.开源的.高性能的HTTP服务器和反向代理服务器:同时也是 ...
- React中对render进行的小优化
react中state和props变化会造成render的重新渲染,有时候我们会在render函数中进行一些稍微复杂的逻辑运算 比如说,像下边这种 在props中将 industries引入,然后对其 ...