首页 > 代码库 > 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 - 如果当前线程不是此对象监视器(锁)的所有者异常