OS 多个生产者--消费者间线程通信

class ProducerConsumeerDemo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);　　　　 Producer pro2 = new Producer(r); 　　　　 Consumer con2 = new Consumer(r);

        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro2);　　　 　Thread t3 = new Thread(con);　　　　 Thread t4 = new Thread(con2);

        t1.start();
        t2.start();
        //System.out.println();
    }
}

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

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

        System.out.println(Thread.currentThread().getName()+ "--111----Producer" +this.name);
        flag = true;
        this.notifyAll();

    }

    public synchronized void out()
    {
        while(!flag)
            try{wait();} catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+ "--222--Consumer"+this.name);
        flag = false;
        this.notifyAll();//this指的是资源对象，锁即资源
    }
}

class Producer implements Runnable
{
    private Resource res;

    Producer(Resource res)
    {
        this.res =  res;
    }
    public void run()
    {
        while(true)
            res.set("+33");
    }
}

class Consumer implements Runnable
{
    private Resource res;

    Consumer(Resource res)
    {
        this.res =  res;
    }
    public void run()
    {
        while(true)
            res.out();
    }
}

t1 t3 ---生产者

t2 t4 ---消费者

针对notify（）；

当t1生产一个产品后，flag判断完之后 wait一下 （释放锁，cpu） 接着t2 t3 t4 抢夺cpu 如，t2抢到后 也wait了 　内存池（存放同一个锁的等待线程）t1 ---> t2

到了t3 消费了一个唤醒了t1 ，t3进入内存池，t4抢到cpu ，也wait了，进入内存池，t1执行，唤醒t2，t2执行，这样产生了生产两个产品，但是第一个被第二个覆盖了。出现ERROR

针对notifyAll（）

当t1生产一个产品后，flag判断完之后 wait一下 （释放锁，cpu） 接着t2 t3 t4 抢夺cpu 如，t2抢到后 也wait了 　内存池（存放同一个锁的等待线程）t1 ---> t2

到了t3 消费了一个唤醒了所有线程 ，t3进入内存池，t4抢到cpu ，也wait了，进入内存池，t1执行，唤醒所有线程。