使用lock/condition实现生产者消费者模式

Condition

Condition 将 Object的通信方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 通信方法的使用。

在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。

Condition的强大之处在于它可以为多个线程间建立不同的Condition， 使用synchronized/wait()只有一个阻塞队列，notifyAll会唤起所有阻塞队列下的线程，而使用lock/condition，可以实现多个阻塞队列，signalAll只会唤起某个阻塞队列下的阻塞线程。
代码：

class Buffer {
    private  final Lock lock;
    private  final Condition notFull;
    private  final Condition notEmpty;
    private int maxSize;
    private List storage;
    Buffer(int size){
        //使用锁lock，并且创建两个condition，相当于两个阻塞队列
        lock=new ReentrantLock();
        notFull=lock.newCondition();
        notEmpty=lock.newCondition();
        maxSize=size;
        storage=new LinkedList<>();
    }
    public void put()  {
        lock.lock();
        try {
            while (storage.size() ==maxSize ){//如果队列满了
                System.out.print(Thread.currentThread().getName()+": wait \n");;
                notFull.await();//阻塞生产线程
            }
            storage.add(new Date());
            System.out.print(Thread.currentThread().getName()+": put:"+storage.size()+ "\n");
            Thread.sleep(5000);
            notEmpty.signalAll();//唤醒消费线程
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }

    public void take() {
        lock.lock();
        try {
            while (storage.size() ==0 ){//如果队列满了
                System.out.print(Thread.currentThread().getName()+": wait \n");;
                notEmpty.await();//阻塞消费线程
            }

            System.out.print(Thread.currentThread().getName()+": take:"+storage.size()+ "\n");
            Date d=((LinkedList)storage).poll();
            Thread.sleep(5000);
            notFull.signalAll();//唤醒生产线程

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}

class Producer implements Runnable{
    private Buffer buffer;
    Producer(Buffer b){
        buffer=b;
    }
    @Override
    public void run() {
        while(true){
            buffer.put();
        }
    }
}
class Consumer implements Runnable{
    private Buffer buffer;
    Consumer(Buffer b){
        buffer=b;
    }
    @Override
    public void run() {
        while(true){
            buffer.take();
        }
    }
}
public class Main {

    public static void main(String[] arg){
        Buffer buffer=new Buffer(10);
        Producer producer=new Producer(buffer);
        Consumer consumer=new Consumer(buffer);
        for(int i=0;i<3;i++){
            new Thread(producer,"producer-"+i).start();
        }
        for(int i=0;i<3;i++){
            new Thread(consumer,"consumer-"+i).start();
        }
    }
}

• 当生产者执行put方法时，调用notEmpty.signalAll()只会唤醒notEmpty.await()下的消费者线程。
• 当消费者执行take方法时，调用notFull.signalAll()只会唤醒notFull.await()下的消费者线程。
  执行结果：

producer-0: put:1
producer-0: put:2
producer-0: put:3
producer-0: put:4
producer-0: put:5
producer-0: put:6
producer-0: put:7
producer-0: put:8
producer-0: put:9
producer-0: put:10
producer-0: wait 
producer-1: wait 
producer-2: wait 
consumer-0: take:10
consumer-0: take:9
consumer-0: take:8
consumer-0: take:7
consumer-0: take:6
consumer-0: take:5
consumer-0: take:4
consumer-0: take:3
consumer-0: take:2
consumer-0: take:1
consumer-0: wait 
consumer-1: wait 
consumer-2: wait 
producer-0: put:1
producer-0: put:2
producer-0: put:3
producer-0: put:4
producer-0: put:5
producer-0: put:6
producer-0: put:7
producer-0: put:8
producer-0: put:9
producer-0: put:10
producer-0: wait 
producer-1: wait 
producer-2: wait 
consumer-0: take:10
consumer-0: take:9
consumer-0: take:8
consumer-0: take:7
consumer-0: take:6
consumer-0: take:5
consumer-0: take:4
consumer-0: take:3
consumer-0: take:2
consumer-0: take:1
consumer-0: wait 
consumer-1: wait 
consumer-2: wait 
producer-0: put:1
producer-0: put:2
producer-0: put:3
producer-0: put:4
producer-0: put:5
producer-0: put:6
producer-0: put:7
producer-0: put:8
producer-1: put:9

完毕。