Lock锁的生产者和消费者

Synchronized版的生产者消费者

public class PCLock {
    public static void main(String[] args) {
        Container2 c = new Container2();
        new Producer2(c).start();
        new Customer2(c).start();
    }

}
class Producer2 extends Thread{
    Container2 container;
    public Producer2(Container2 container){
        this.container=container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("生产产品"+i);
            container.push(new Product(i));
        }
    }
}
class Product2{
    private int id;
    public Product2(int  id) {
        this.id = id;
    }
}
class Customer2 extends Thread{
    Container2 container;
    public Customer2(Container2 container){
        this.container=container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("消费了"+i);
            container.pop();
        }
    }
}
class Container2{
    Product[] products = new Product[10];
    int count=0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public  void push(Product p){
        try {
            lock.lock();
            while(count==products.length){
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            products[count] = p;
            count++;
            condition.signalAll();
        }finally {
            lock.unlock();
        }

    }
    public void pop(){
        try{
            lock.lock();
            while(count==0){
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count--;
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

官方文档如下：

/*Condition因素出Object监视器方法（ wait ， notify和notifyAll ）成不同的对象，
以得到具有多个等待集的每个对象，通过将它们与使用任意的组合的效果Lock个实现。 
Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。*/
 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock(); try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally { lock.unlock(); }
   }

   public Object take() throws InterruptedException {
     lock.lock(); try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally { lock.unlock(); }
   }
 }