您的位置：首页 > 编程语言 > Java开发

java基础知识回顾之java Thread类学习（八）--java多线程通信等待唤醒机制经典应用（生产者消费者）

2014-08-10 22:09 841 查看
*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
- 如果当前线程不是此对象监视器（锁）的所有者异常
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航