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类改为如下：

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();
        }
    }

}

效果：