首页 > 代码库 > java基础知识回顾之java Thread类学习(八)--java多线程通信等待唤醒机制经典应用(生产者消费者)
java基础知识回顾之java Thread类学习(八)--java多线程通信等待唤醒机制经典应用(生产者消费者)
*java多线程--等待唤醒机制:经典的体现"生产者和消费者模型
*对于此模型,应该明确以下几点:
*1.生产者仅仅在仓库未满的时候生产,仓库满了则停止生产。
*2.消费者仅仅在有产品的时候才能消费,仓空则等待。
*3.当消费者发现仓储没有产品可消费的时候,会唤醒等待生产者生产。
*4.生产者在生产出可以消费的产品的时候,应该通知等待的消费者去消费。
下面先介绍个简单的生产者消费者例子:本例只适用于两个线程,一个线程生产,一个线程负责消费。
生产一个资源,就得消费一个资源。
代码如下:
public class ProduceOneCusumer { /** * @param args */ public static void main(String[] args) { Resource r = new Resource(); Producer pro = new Producer(r); Consumer con = new Consumer(r); Thread t1 = new Thread(pro);//生产者线程 Thread t2 = new Thread(con);//消费者线程 t1.start(); t2.start(); }}/** * 仓储类,仓储原料 * @author Administrator * */class Resource{ private String name;//原料名称 private int count = 1;//生产数量 private boolean flag = false; public synchronized void set(String name){//t1 if(flag){ try { this.wait();//仓库满了,生产者等待,等待消费者消费 } catch (InterruptedException e) { e.printStackTrace(); } } this.name = name+"------"+count++; System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name); this.flag = true; this.notify();//唤醒消费者线程进行消费 } public synchronized void out(){//t2,t3 if(!flag){//false try { this.wait();//仓库为空不能消费,消费者线程等待,等待生产者生产 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(Thread.currentThread().getName()+"......消费者......."+this.name); this.flag = false; this.notify();//唤醒生产者 }}/** * 生产者类 * @author Administrator * */class Producer implements Runnable{ private Resource r; public Producer(Resource r){//把原料放到生产者里面生产,当生产者一创建生产对象,就初始化原料 this.r = r; } @Override public void run() { while(true){//不断的生产 r.set("烤鸭");//生产烤鸭 } }}class Consumer implements Runnable{ private Resource r; public Consumer(Resource r){ this.r = r; } @Override public void run() { while(true){ r.out();//消费者消费 } } }
输出结果:
Thread-1......消费者.......烤鸭------21688
Thread-0..生产者..烤鸭------21689
Thread-1......消费者.......烤鸭------21689
Thread-0..生产者..烤鸭------21690
Thread-1......消费者.......烤鸭------21690
Thread-0..生产者..烤鸭------21691
Thread-1......消费者.......烤鸭------21691
Thread-0..生产者..烤鸭------21692
Thread-1......消费者.......烤鸭------21692
从结果可以得知,生产者线程生产一只烤鸭,消费者就消费一只烤鸭。两个线程交替等待唤醒。
下面我们把上面代码稍微改动下:再增加两个线程,变为两个生产者线程分别为t0,t1,两个消费者线程,分比为t3,t4.改动Main方法,其它不变。
代码如下:
public class ProduceOneCusumer { /** * @param args */ public static void main(String[] args) { Resource r = new Resource(); Producer pro = new Producer(r); Consumer con = new Consumer(r); Thread t0 = new Thread(pro);//生产者线程 Thread t1 = new Thread(pro);//生产者线程 Thread t2 = new Thread(con);//消费者线程 Thread t3 = new Thread(con);//消费者线程 t0.start(); t1.start(); t2.start(); t3.start(); }}
则经过测试代码运行结果:会发现:
第一种情况:生产者线程一直在生产,仓库满了也不消费;
第二种情况:生产了一个 ,消费了多次,也就是说库存里面没有烤鸭了还在消费。
结果如下:
第一种情况:
Thread-0..生产者..烤鸭------28348
Thread-1..生产者..烤鸭------28349
Thread-0..生产者..烤鸭------28350
Thread-1..生产者..烤鸭------28351
Thread-0..生产者..烤鸭------28352
Thread-1..生产者..烤鸭------28353
Thread-0..生产者..烤鸭------28354
Thread-1..生产者..烤鸭------28355
Thread-0..生产者..烤鸭------28356
Thread-1..生产者..烤鸭------28357
Thread-0..生产者..烤鸭------28358
Thread-2......消费者.......烤鸭------28358
第二种情况:
Thread-0..生产者..烤鸭------29432
Thread-2......消费者.......烤鸭------29432
Thread-3......消费者.......烤鸭------29432
Thread-2......消费者.......烤鸭------29432
Thread-3......消费者.......烤鸭------29432
Thread-2......消费者.......烤鸭------29432
结论:多个线程会出现问题,思考原因?
这里分析代码解释第一种情况,第二种情况和第一种情况类试。
代码的执行过程分析:
假设有两个生产线程为t0,t1;两个消费线程为t1,t2。假设开始生产者t0得到了CPU的执行权,进入生产者run方法,拿到this锁,进入set方法,初始值flag = false;所以不走if中的代码,走else中的代码,则生产者生产了一只烤鸭(打印出"Thread-0..生产者..烤鸭1"),thread-0执行完剩余的代码,释放this锁。
这个时候,因为thread-0是执行完run方法中的set方法中的所有代码,释放锁,并没有执行wait方法,那么线程0还可能抢到CUP资源,拿到 锁,再次进入Run方法中的set方法,进入判断if(flag=true),所以线程0(Thread-0)等待。
这时活跃的线程还有t1,t2,t3;一个生产线程,两个消费线程.这个时候还有可能t1抢到CPU的执行权, t1拿到this锁,进入set方法,if(true),那么执行wait,这个时候t1(Thread-1)也等待。
这个时候:还有两个线程活着,t2,t3。假设t2抢到CPU的执行权,在消费者run方法里面运行,执行out函数,拿到锁进入out方法,if 判断,由于上面flag=true;所以不执行if代码,执行else代码,则消费者消费一只烤鸭(打印Thread-2....消费者.....烤鸭1),紧跟着
执行t2执行剩余的代码,flag=false;notify()。
这个时候等待线程池中有2个线程处于冻结状态,分别为t0,t1。当执行notify()方法的时候,“就可以唤醒同锁中等待的线程中的一个”。可能是t1,也可能是t2。假设t1被唤醒,这时活跃的线程还包括t2,t3,t0.假设还是t2抢到CPU执行权,t2进入out,由于flag被置为flase,那么if判断,这个时候t2执行wait方法,等待。这个时候剩余t0,t3是活着的,假设t3抢到执行权,拿到锁进入out方法,判断,t3也等待。这个时候还有一个线程处于活跃状态,那就是t0.
关键就是这个地方:四个线程t1,t2,t3都执行了wait方法进入等待状态,t0那会儿执行wait,刚被notify唤醒,唤醒之后,直接执行else里面的代码,这时候生产者生产了一只烤鸭(打印出"Thread-0..生产者..烤鸭2"),flag=true,这个时候执行notify,最悲剧的是有可能唤醒了t1,和t0一样的生产者。这个时候两个生产者线程活着。为t0,t1,可能t0抢到CPU执行权,进入set,if判断,执行wait,t0等待,这个时候活过来的只剩t1,由于t1是从wait中活过来的,所以不用if判断,执行else中的代码,生产者生产了一只烤鸭(打印出"Thread-1..生产者..烤鸭3")。这样flag=true,notify,又有可能唤醒t0,t2,t3中的t1.这样可能形成一个规律就是只生产,不消费。就会导致上面的结果。
造成的根本原因是:if只判断一次,当等待的线程醒过来以后,没有执行if判断,那么使用while循环就可以解决这个问题,等待的线程醒过来之后还会判断里面的条件。
代码变成:把if改为while:
public class ProduceOneCusumer { /** * @param args */ public static void main(String[] args) { Resource r = new Resource(); Producer pro = new Producer(r); Consumer con = new Consumer(r); Thread t0 = new Thread(pro);//生产者线程 Thread t1 = new Thread(pro);//生产者线程 Thread t2 = new Thread(con);//消费者线程 Thread t3 = new Thread(con);//消费者线程 t0.start(); t1.start(); t2.start(); t3.start(); }}/** * 仓储类,仓储原料 * @author Administrator * */class Resource{ private String name;//原料名称 private int count = 1;//生产数量 private boolean flag = false; public synchronized void set(String name){//t1 while(flag){ try { this.wait();//仓库满了,生产者等待,等待消费者消费 } catch (InterruptedException e) { e.printStackTrace(); } } this.name = name+"------"+count++; System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name); this.flag = true; this.notify();//唤醒消费者线程进行消费 } public synchronized void out(){//t2,t3 while(!flag){//false try { this.wait();//仓库为空不能消费,消费者线程等待,等待生产者生产 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(Thread.currentThread().getName()+"......消费者......."+this.name); this.flag = false; this.notify();//唤醒生产者 }}/** * 生产者类 * @author Administrator * */class Producer implements Runnable{ private Resource r; public Producer(Resource r){//把原料放到生产者里面生产,当生产者一创建生产对象,就初始化原料 this.r = r; } @Override public void run() { while(true){//不断的生产 r.set("烤鸭");//生产烤鸭 } }}class Consumer implements Runnable{ private Resource r; public Consumer(Resource r){ this.r = r; } @Override public void run() { while(true){ r.out();//消费者消费 } } }
测试结果:不会出现上面的那两种情况了,但可能出现死锁。
Thread-0..生产者..烤鸭------1
Thread-2......消费者.......烤鸭------1
Thread-1..生产者..烤鸭------2
Thread-2......消费者.......烤鸭------2
Thread-0..生产者..烤鸭------3
Thread-2......消费者.......烤鸭------3
Thread-0..生产者..烤鸭------4
Thread-2......消费者.......烤鸭------4
Thread-0..生产者..烤鸭------5
Thread-3......消费者.......烤鸭------5
Thread-0..生产者..烤鸭------6
Thread-2......消费者.......烤鸭------6
死锁原因:
当改成while循环后,由于刚上面的分析t1从等待中唤醒,t0,t2,t3等待了,由于flag=true,改成while循环后,会再次判断标志,while条件成立,则t1执行wait方法,等待。这个时候t0,t1,t2,t3都处于等待状态,没有线程唤醒,那么出现了死锁。简单的说就是四个线程都等待,没有活着的线程,程序出现死锁,不会循环生产和消费。
那么怎么解决呢:把notify改为notifyAll方法,出现的原因是每次只能任意的唤醒一个线程,当改成notifyAll方法后可以唤醒所有等待的线程。
最终多个线程的消费者生产者程序问题全部解决。
总结:两个线程用if判断可以,多个线程的生产者消费者问题用while循环判断标志。在分析的过程中我们可以理解wait,notify和notifyAll的用法,三个方法都用在同一个资源当中的同一个锁中,成对出现,必须用在同步(锁)当中,否则会出现IllegalMonitorStateException
- 如果当前线程不是此对象监视器(锁)的所有者异常