java线程之多个生产者消费者

温故一下上一节所学习的生产者消费者代码：

两个线程时：

通过标志位flag的if判断和同步函数互斥较好解决两个线程，一个生产者、一个消费者交替执行的功能

类名：ProducterConsumerDemo.java

代码：

class  ProducterConsumerDemo
{
public static void main(String[] args)
{
Resources  r =new Resources();
Productor  pro =new Productor(r);
Consumer   con = new Consumer(r);

Thread t1 =new Thread(pro);
Thread t2 =new Thread(con);
t1.start();
t2.start();
System.out.println("Hello World!");
}
}

class Resources
{
private String name;
private int count =1;
private boolean flag =false;

public synchronized void set(String name)
{
if(flag)
try{this.wait();}catch(Exception e){}
this.name = name+"--"+count++;

System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
flag =true;
//唤醒对方进程
this.notify();

}
public synchronized void out()
{
if(!flag)
try{this.wait();}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+" ....消费者...."+this.name);
flag =false;
//唤醒对方进程
this.notify();

}
}

class Productor implements Runnable
{
private Resources res;
Productor(Resources res){
this.res =res;
}
public void run(){
while(true){
res.set("++商品++");
}
}

}

class Consumer  implements Runnable
{
private Resources res;
Consumer(Resources res){
this.res =res;
}
public void run(){
while(true){
res.out();
}
}

}

ProducterConsumerDemo.java

如果再多加上两个线程呢？

　　即把其中的ProducterConsumerDemo类改为如下：

class  ProducterConsumerDemo2
{
public static void main(String[] args)
{
Resources  r =new Resources();
Productor  pro =new Productor(r);
Consumer   con = new Consumer(r);

Thread t1 =new Thread(pro);
Thread t2 =new Thread(pro);//多个生产者
Thread t3 =new Thread(con);
Thread t4 =new Thread(con);//多个消费者
t1.start();
t2.start();
t3.start();
t4.start();
System.out.println("Hello World!");
}
}

运行后发现，加上t3和t4之后结果就错了。

　　为什么两个线程的时候执行结果正确而四个线程的时候就不对了呢？

　　因为线程在wait()的时候，接收到其他线程的通知，即往下执行，不再进行判断。两个线程的情况下，唤醒的肯定是另一个线程；但是在多个线程的情况下，执行结果就会混乱无序。

　　比如，一个可能的情况是，一个增加线程执行的时候，其他三个线程都在wait，这时候第一个线程调用了notify()方法，其他线程都将被唤醒，然后执行各自的增加或减少方法。

　　解决的方法就是：在被唤醒之后仍然进行条件判断，去检查要改的数字是否满足条件，如果不满足条件就继续睡眠。

1）把两个方法中的if改为while即可。

　　　　　　　　　 2）需要将notify()改成notifyAll()

代码：

 /*
ProducterConsumerDemo解决了只有两个线程共享资源的生产消费问题，主要利用标志位的互斥解决

本程序致力于解决多出现多个生产者，多个消费者的时候，依然能够达到生产一次，消费一次的功能
：
解决的方法就是：1)在被唤醒之后仍然进行条件判断，去检查要改的数字是否满足条件，如果不满足条件就继续睡眠。把两个方法中的if改为while即可。
当然，此时仍会出现问题，就是所以线程都等待，失去资格
2)需要将notify()改成notifyAll()
*/

class  ProducterConsumerDemo2
{
public static void main(String[] args)
{
Resources  r =new Resources();
Productor  pro =new Productor(r);
Consumer   con = new Consumer(r);

Thread t1 =new Thread(pro);
Thread t2 =new Thread(pro);//多个生产者
Thread t3 =new Thread(con);
Thread t4 =new Thread(con);//多个消费者
t1.start();
t2.start();
t3.start();
t4.start();
System.out.println("Hello World!");
}
}

class Resources
{
private String name;
private int count =1;
private boolean flag =false;

public synchronized void set(String name)
{  //1)循环判断
while(flag)
try{this.wait();}catch(Exception e){}
this.name = name+"--"+count++;

System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
flag =true;
//2)唤醒所有进程
this.notifyAll();

}
public synchronized void out()
{
//1)循环判断
while(!flag)
try{this.wait();}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+" ....消费者...."+this.name);
flag =false;
//2)唤醒所有进程
this.notifyAll();

}
}

class Productor implements Runnable
{
private Resources res;
Productor(Resources res){
this.res =res;
}
public void run(){
while(true){
res.set("++商品++");
}
}

}

class Consumer  implements Runnable
{
private Resources res;
Consumer(Resources res){
this.res =res;
}
public void run(){
while(true){
res.out();
}
}

}

效果：