生产者和消费者问题

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

/*
 * 生产者消费者问题
 * 两个个生产者，两个消费者，生产一个，消费一个。
 * 实际生活当中一般是多个生产者，多个消费者的情况
 *
 * JDK1.5中提供了多线程升级解决方案
 * 将同步的Synchronized 替换成现实的lock操作
 * 将Object中的wait()、notify()、notifyAll(),替换为Condition对象
 *  Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，
 *  以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。
 *  其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
 * Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，
 * 该对象可以进行Lock锁，进行获取
 * 该实例中，实现了本方唤醒对方的操作
 *
 *
 *  * */


public class UpgradeProduce {

    public static void main(String[] args) {

        Factory f=new Factory(); //创建一个工厂
        Thread t1=new Thread(new Produce(f)); //生产者A
        Thread t11=new Thread(new Produce(f));//生产者B
        Thread t2=new Thread(new Consume(f)); //消费者A
        Thread t22=new Thread(new Consume(f)); //消费者B

        t1.start(); //生产者A 准备生产
        t11.start();//生产者B 准备生产
        t2.start(); //消费者A  准备消费
        t22.start();//消费者B  准备消费

    }

}

class Factory //生产车间
{
    private String name;
    private int count=1; //商品编号
    private boolean flag=false; //标志位，

    private Lock lock=new ReentrantLock(); //创建Lock实例
    private Condition condition_pro=lock.newCondition(); //生产者监视器
    private Condition condition_con=lock.newCondition(); //消费者监视器

    public void set(String name) //生产商品
    {
        lock.lock();
        try{
            while(flag) //如果生产了一个 ，生产者就等待
             condition_pro.await();
            this.name=name+"--->"+count++;
            System.out.println(Thread.currentThread().getName()+"-生产者-"+this.name);
            flag=true;
            condition_con.signal(); //唤醒消费者开始消费
         }
        catch(InterruptedException e){e.printStackTrace();}
        finally//释放锁
        {
            lock.unlock();
        }

    }
    public void out() //消费商品
    {
        lock.lock();
        try
        {
            while(!flag) //如果消费了一个，消费者就等待，
             {condition_con.await();}
            System.out.println(Thread.currentThread().getName()+"  -消费者-  "+this.name);
            flag=false;
            condition_pro.signal(); //唤醒生产者继续生产
         }
        catch(InterruptedException e){e.printStackTrace();}
        finally //释放锁
        {
            lock.unlock();
        }

    }

}

class Produce implements Runnable //生产者线程
{
     private Factory f;
     public Produce(Factory f)
     {
         this.f=f;
     }
     public void run()
     {
         while(true)
         f.set("=商品=");//开始生产
     }
}

class Consume implements Runnable //消费者线程
{
    private Factory f;
    public Consume(Factory f)
    {
        this.f=f;
    }
    public void run()
    {
        while(true)
        f.out(); //消费
    }
}

运行结果：
Thread-1-生产者-=商品=--->34317
Thread-3  -消费者-  =商品=--->34317
Thread-0-生产者-=商品=--->34318
Thread-3  -消费者-  =商品=--->34318
Thread-1-生产者-=商品=--->34319
Thread-3  -消费者-  =商品=--->34319
Thread-0-生产者-=商品=--->34320
Thread-3  -消费者-  =商品=--->34320
Thread-1-生产者-=商品=--->34321
Thread-3  -消费者-  =商品=--->34321
Thread-0-生产者-=商品=--->34322
Thread-3  -消费者-  =商品=--->34322
Thread-1-生产者-=商品=--->34323
Thread-3  -消费者-  =商品=--->34323
Thread-0-生产者-=商品=--->34324
Thread-3  -消费者-  =商品=--->34324
......
Thread-1-生产者-=商品=--->29802
Thread-2  -消费者-  =商品=--->29802
Thread-0-生产者-=商品=--->29803
Thread-3  -消费者-  =商品=--->29803
Thread-1-生产者-=商品=--->29804
Thread-2  -消费者-  =商品=--->29804
Thread-0-生产者-=商品=--->29805
Thread-3  -消费者-  =商品=--->29805
Thread-1-生产者-=商品=--->29806
Thread-2  -消费者-  =商品=--->29806

....
....
....