Java并发(八)生产消费问题&虚假唤醒
2017-05-06 01:14
267 查看
描述
生产消费问题在java多线程的学习中是经常遇到的问题 ,多个线程共享通一个资源的时候会出现各种多线程中经常出现的各种问题。实例说明
三个类:售货员Clerk,工厂Factory,消费者ConsumerFactory和Consumer共享Clerk对象
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; } } }
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();//进货 } } }
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("没货了"); 10ee6 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的之后短路,使得消费和线程啥都不做,直到线程结束。
Clerk中设置Factory线程的标志位
private boolean facctoryFlg = true;//工厂线程结束的标志位,为false表示线程执行完毕 public boolean isFacctoryFlg() { return facctoryFlg; } public void setFacctoryFlg(boolean facctoryFlg) { this.facctoryFlg = facctoryFlg; }
主方法中创建守护线程
//创建守护线程 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();
修改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只要在守护线程中添加判断逻辑,就可以避免阻塞的出现。
相关文章推荐
- Java中多线程的多生产多消费问题的解决方案
- 【Java】----线程同步:生产-消费问题
- Java多线程的单生产单消费和多生产多消费问题的解决
- java多线程之生产消费问题
- java信号量解决生产消费问题
- JAVA进阶6.8——生产消费问题
- 黑马程序员_java的多线程进阶(对第十二课等待唤醒机制和生产消费总结)
- 并发队列ConcurrentLinkedQueue和阻塞队列LinkedBlockingQueue用法 在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列(先进先出)。
- 生产者消费者问题 这是一个非常经典的多线程题目,题目大意如下:有一个生产者在生产产品,这些产品将提供给若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之间设置一个有多个缓冲区的缓冲池,生产者
- 生产者消费者问题 这是一个非常经典的多线程题目,题目大意如下:有一个生产者在生产产品,这些产品将提供给若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之间设置一个有多个缓冲区的缓冲池,生产者
- java学习9:生产和消费问题,先生产才能消费,线程间通信与等待
- 在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。
- Java 多线程间通信 多生产 多消费问题
- Java模拟生产消费问题
- 多线程__【线程间通信】【等待唤醒机制】【多生产多消费】【Lock&Condition接口】
- 多线程__【线程间通信】【等待唤醒机制】【多生产多消费】【Lock&Condition接口】
- Java 线程同步 生产消费问题
- 生产者消费者问题 这是一个非常经典的多线程题目,题目大意如下:有一个生产者在生产产品,这些产品将提供给若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之间设置一个有多个缓冲区的缓冲池,生产者
- 解决在arm2440休眠唤醒后出现大量类似"**>> yaffs chunk 123 was not erased"的问题
- Registry key 'Software/JavaSoft/Java Runtime Environment/CurrentVersion'问题解决