描述

生产消费问题在java多线程的学习中是经常遇到的问题 ,多个线程共享通一个资源的时候会出现各种多线程中经常出现的各种问题。

实例说明

三个类:售货员Clerk,工厂Factory,消费者Consumer

Factory和Consumer共享Clerk对象

1.普通情况

  1. Clerk类:
class Clerk{
//商品数量默认是0,volatile关键字保证内存可见性
private volatile int product=0; //进货,synchronized关键字保证原子性,互斥性
public synchronized void get(){
if(product>10){
System.out.println("货满了");
}else {
++product;
System.out.println(Thread.currentThread().getName()+"进货"+product);
}
} //售货
public synchronized void sale(){
if(product<=0){
System.out.println("没货了");
}else{
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
}
}
}
  1. Factory类:
class Factory implements Runnable{

    private Clerk clerk;

    Factory(Clerk clerk){
this.clerk = clerk;
} @Override
public void run() {
for(int i=0;i<20;i++){
clerk.get();//进货
}
} }
  1. Consumer类:
class Consumer implements Runnable{

    private Clerk clerk;

    Consumer(Clerk clerk){
this.clerk = clerk;
} @Override
public void run() {
for(int i=0;i<20;i++){
clerk.sale();//卖货
} }
}

测试:

public static void main(String[] args) {

        Clerk clerk = new Clerk();
Factory factory = new Factory(clerk);
Consumer consumer = new Consumer(clerk); Thread tf = new Thread(factory);
Thread tc = new Thread(consumer); tf.start();
tc.start(); }

输出结果:

Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-0进货8
Thread-0进货9
Thread-0进货10
Thread-0进货11
货满了
货满了
货满了
货满了
货满了
货满了
货满了
货满了
货满了
Thread-1卖货11
Thread-1卖货10
Thread-1卖货9
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了

问题出现了,每次进货只有在进货满了的情况下,才会买货,当进货的次数执行完了之后才会执行卖货的方法,而且卖货没货的时候一直输出没货不会等待商家进货。

1. 重复调用占用资源问题

原因分析 :

上述的情况是当没货的时候还会继续调用该方法,从而占用资源,二货满的情况下也会重复调用进货方法,占用资源,这样是不合理的。

解决方式:

当货满了,应该停止进货,释放锁让消费者消费,当没货了应该停止消费释放锁,让进货,这是我们想要的逻辑。

使用wait()notifyAll()这两个方法来实现。

修改Clerk的get和sale方法如下:

class Clerk{
//商品数量默认是0
private volatile int product=0; //进货
public synchronized void get(){
if(product>10){
System.out.println("货满了");
try {
this.wait();//等待并释放clerk的对象锁,进入线程队列等待被唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
++product;
System.out.println(Thread.currentThread().getName()+"进货"+product);
notifyAll();//唤醒等待的线程
}
} //售货
public synchronized void sale(){
if(product<=0){
System.out.println("没货了");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
notifyAll();
}
}
}

输出测试:

Thread-0进货1
Thread-1卖货1
没货了
Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-0进货8
Thread-0进货9
Thread-0进货10
Thread-0进货11
货满了
Thread-1卖货11
Thread-1卖货10
Thread-1卖货9
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1
没货了
Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2

这样看起来和谐多了,但是还存在一个小问题,那就是当商品数量变少的时候,而且Factory或者Consumer的run方法内Thread.sleep()方法进行延时,在真是的项目中,这中延时是真实存在的。会产生一方提前结束了,而另外一方没有被唤醒的的情况,从而导致线程一直在等待无法结束的情况产生。

2. 线程阻塞无法唤醒

当product比较小假如是1的时候,有可能生产者先循环结束,

消费者还没结束,一直在waite无法得到唤醒就一直等待

程序就会停在那里

解决方式:去掉else,保证每次都会唤醒另外一个线程

//店员
class Clerk{
private int product;
private volatile boolean proFlg=true;//生产者是否完结的标志位
public boolean isProFlg() {
return proFlg;
} public void setProFlg(boolean proFlg) {
this.proFlg = proFlg;
}
public synchronized void addProduct(){
while(product>=10){
try {
wait();//大于10各产品,停止生产
} catch (InterruptedException e) {
e.printStackTrace();
}
}//else{
product++;
System.out.println(Thread.currentThread().getName()+"生产:"+product);
notifyAll();
//}
} public synchronized void saleProduct(){
while(product <= 0 && !this.isProFlg()){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}//大于10各产品,停止消费
}//else {
System.out.println(Thread.currentThread().getName()+"消费:"+product);
product--;
notifyAll();
//}
} }

3.虚假唤醒问题

Clerk clerk = new Clerk();
Factory factory = new Factory(clerk);
Consumer consumer = new Consumer(clerk); Thread tf = new Thread(factory);
Thread tc = new Thread(consumer);
Thread tc2 = new Thread(consumer);
tf.start();
tc.start();
tc2.start();

输出结果:

没货了
没货了
Thread-0进货1
Thread-2卖货1
没货了
Thread-1卖货0
没货了
Thread-2卖货-1
没货了
Thread-1卖货-2
没货了
Thread-2卖货-3
没货了
Thread-1卖货-4
没货了
Thread-2卖货-5
没货了
Thread-1卖货-6

当只有一个Factory有两个Consumer的时候就会出现虚假唤醒问题。导致商品都成了负数了。

原因分析:

当创建对个生产消费者线程的时候,会产生虚假唤醒,导致product

为负数,是因为当消费者线程A发现没货的时候,wait之后释放锁,另外一个

消费者线程B获得锁开始执行,结果也没货,开始wait,当生产者生产之后

notifyAll,A,B线程开始继续向下执行,结果进行了两次–操作,导致

product成为了负数

解决方式:

JDK文档object的wait方法已经考虑到这种情况,防止虚假唤醒,应该放在循环中,多次进行检查,直到满足条件才进行下一步

class Clerk{
//商品数量默认是0
private volatile int product=0; //进货
public synchronized void get(){
while(product>10){
System.out.println("货满了");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
++product;
System.out.println(Thread.currentThread().getName()+"进货"+product);
notifyAll(); } //售货
public synchronized void sale(){
while(product<=0){
System.out.println("没货了");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
notifyAll(); }
}

4. 守护线程解决线程阻塞

上面解决了虚假唤醒问题,但是当多个消费者和一个生产者的时候,生产者有可能先结束循环,但是消费者还没结束,结果到了其他消费者的时候发现product是小于0的于是就wait,程序一直等待得不到结束,就会一直在wait()

解决方式:

在共享资源clerk类中定义生产者线程标志位,在main线程中创建一个线程设置为守护线程

并启动,在该守护线程中创建匿名内部类Runnable并在run方法中判断生产者线程isAlive()

如果生产者线程结束,就把标志位置为false,该标识位和消费者线程的while判断条件中串联

当生产者线程为false的之后短路,使得消费者线程啥都不做,直到线程结束。

  1. Clerk中设置Factory线程的标志位
private boolean facctoryFlg = true;//工厂线程结束的标志位,为false表示线程执行完毕
public boolean isFacctoryFlg() {
return facctoryFlg;
} public void setFacctoryFlg(boolean facctoryFlg) {
this.facctoryFlg = facctoryFlg;
}
  1. 主方法中创建守护线程
//创建守护线程
Thread daemon = new Thread(new Runnable() {
@Override
public void run() {
while(true){
if(!tf.isAlive()){
clerk.setFacctoryFlg(false);
System.out.println("factory--------------"+tf.isAlive());
break;
}
}
}
});
daemon.setDaemon(true);//设置为守护线程(后台线程)
daemon.start();
  1. 修改Clerk的sale方法:
//售货
public synchronized void sale(){ while(product<=0){
//当Factory线程结束的时候,直接结束sale方法
if(!isFacctoryFlg()){
return;
}
System.out.println("没货了");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"卖货"+product);
--product;
notifyAll();
}

通过守护线程daemon的监视,可以避免线程阻塞的情况,就算有多个消费者或者Factory只要在守护线程中添加判断逻辑,就可以避免阻塞的出现。

7.JUC线程高级-生产消费问题&虚假唤醒的更多相关文章

  1. (二)juc线程高级特性——CountDownLatch / Callable / Lock

    5. CountDownLatch 闭锁 Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能. CountDownLatch 一个同步辅助类, ...

  2. (四)juc线程高级特性——线程池 / 线程调度 / ForkJoinPool

    13. 线程池 第四种获取线程的方法:线程池,一个 ExecutorService,它使用可能的几个池线程之一执行每个提交的任务,通常使用 Executors 工厂方法配置. 线程池可以解决两个不同问 ...

  3. (一)juc线程高级特性——volatile / CAS算法 / ConcurrentHashMap

    1. volatile 关键字与内存可见性 原文地址: https://www.cnblogs.com/zjfjava/category/979088.html 内存可见性(Memory Visibi ...

  4. Java多线程中的虚假唤醒和如何避免

    先来看一个例子 一个卖面的面馆,有一个做面的厨师和一个吃面的食客,需要保证,厨师做一碗面,食客吃一碗面,不能一次性多做几碗面,更不能没有面的时候吃面:按照上述操作,进行十轮做面吃面的操作. 用代码说话 ...

  5. (三)juc高级特性——虚假唤醒 / Condition / 按序交替 / ReadWriteLock / 线程八锁

    8. 生产者消费者案例-虚假唤醒 参考下面生产者消费者案例: /* * 生产者和消费者案例 */ public class TestProductorAndConsumer { public stat ...

  6. JUC虚假唤醒(六)

    为什么条件锁会产生虚假唤醒现象(spurious wakeup)? ​ 在不同的语言,甚至不同的操作系统上,条件锁都会产生虚假唤醒现象.所有语言的条件锁库都推荐用户把wait()放进循环里: whil ...

  7. kafka生产消费原理笔记

    一.什么是kafka Kafka是最初由Linkedin公司开发,是一个分布式.支持分区的(partition).多副本的(replica),基于zookeeper协调的分布式消息系统,它的最大的特性 ...

  8. 线程高级篇-Lock锁实现生产者-消费者模型

    Lock锁介绍: 在java中可以使用 synchronized 来实现多线程下对象的同步访问,为了获得更加灵活使用场景.高效的性能,java还提供了Lock接口及其实现类ReentrantLock和 ...

  9. 第44天学习打卡(JUC 线程和进程 并发和并行 Lock锁 生产者和消费者问题 如何判断锁(8锁问题) 集合类不安全)

    什么是JUC 1.java.util工具包 包 分类 业务:普通的线程代码 Thread Runnable 没有返回值.效率相比Callable相对较低 2.线程和进程 进程:一个程序.QQ.exe, ...

随机推荐

  1. 【tensorflow2.0】数据管道dataset

    如果需要训练的数据大小不大,例如不到1G,那么可以直接全部读入内存中进行训练,这样一般效率最高. 但如果需要训练的数据很大,例如超过10G,无法一次载入内存,那么通常需要在训练的过程中分批逐渐读入. ...

  2. Linux bash篇,基本信息和变量

    1.shells目录       /etc/shells 2.查看用户所具有的shell    /etc/passwd 3.查看当前用户执行过的shell      ~/.bash_history 4 ...

  3. 第一章 AT&T

    1.一个公司(企业)越庞大,就越危险:越复杂,就越濒临坍塌:快速发展的同时,也埋下了隐患. 2.再庞大的企业也不可能永久站立,下个十年谁也说不准谁会在浪潮之巅. 3.一个人能走多远,往往取决于他能看多 ...

  4. 学习《深入应用c++11》1

    C++11 让程序更简洁.更优雅 可调用对象 是一个函数指针 是一个具有operator()成员函数的类对象(仿函数) 是一个可被装换为函数指针的类对象 是一个类的成员(函数)指针 void func ...

  5. js及jquery常用插件

    1.backstretch背景图片插件 可实现背景自适应效果 <script src="dist/js/lib/backstretch/jquery.backstretch.min.j ...

  6. Mysqldump参数大全 这 些参数 不同于 mysql 的那些参数(下边文章开头有链接) :2 种类型的参数含义是不一样的

    Mysqldump参数大全  这 些参数 不同于 mysql 的那些参数  :2 种类型的参数含义是不一样的 Mysqldump参数大全(参数来源于mysql5.5.19源码) 参数 参数说明 --a ...

  7. **********Prometheus(三)******************

    通过centos7.x来部署Prometheus ####同步时间,否则后面监控会有异常!!!!!####### 1. 创建文件夹,上传软件包.解压并将prometheus promtool两个命令复 ...

  8. L25词嵌入进阶GloVe模型

    词嵌入进阶 在"Word2Vec的实现"一节中,我们在小规模数据集上训练了一个 Word2Vec 词嵌入模型,并通过词向量的余弦相似度搜索近义词.虽然 Word2Vec 已经能够成 ...

  9. vue中的ref属性

    1.什么是ref? ref是用于快速定位到dom结构,vue中一般不去操作dom结构,他是数据驱动的.jQuery会疯狂操作DOM {{msg}} mounted(){ let h = this.$r ...

  10. D - Leading and Trailing LightOJ - 1282

    题解:求n^k的前三位和后三位. 后三位直接快速幂对1000去余就可以了.前三位可以转换成浮点数来操作,也是用快速幂,我们只保留答案的前三位,当前值大于1000.0的话就除以10,直到结果小于等于10 ...