7.生产者消费者 案例 （使用Lock 同步锁 方式，使用Condition完成线程之间的通信）

 /*
  * 生产者消费者 案例 （使用Lock 同步锁 方式，使用Condition完成线程之间的通信）
  * */
 public class TestProductorAndConsumerForLock {
     public static void main(String[] args) {
         WareHouse wareHouse = new WareHouse();
         Productor pd1 = new Productor(wareHouse);
         Consumer cs1 = new Consumer(wareHouse);

         new Thread(pd1, "消费者1").start();
         new Thread(cs1, "生产者1").start();
         // 若有多个 生产者消费者，可能会产生虚假唤醒（缺货了，多个生产线程等待，唤醒时，这些生产线程同时醒来，对数据进行操作，这种问题叫做虚假唤醒）
         // 解决办法：wait方法 尽量 使用在循环中，被唤醒之后，再去判断是否符合条件（库存是否达到上限），不符合条件
         // 继续等待（等待消费者去消费商品），直到 条件符合（库存有空闲）
         new Thread(pd1, "消费者2").start();
         new Thread(cs1, "生产者2").start();
     }
 }

 // 仓库
 class WareHouse {
     // 商品数量
     private int products = 0;
     private ReentrantLock lock = new ReentrantLock();
     //使用 Condition 的前提是 使用 Lock 同步锁，Condition 实例 实质上被绑定到一个锁上
     private Condition condition = lock.newCondition();

     public void set() {
         lock.lock();
         try {
             while (products >= 1) {
                 System.out.println("商品库存满了");
                 try {
                     // 如果商品满了，阻塞线程，等待消费者线程消费完成后唤醒，
                     condition.await();  //相当于（Object.awatit() 但是功能更强大）
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
             System.out.println("生产了商品，剩余库存" + ++products);
             condition.signalAll();     //相当于 （Object.notifyAll，功能更强大）
         } finally {
             lock.unlock();
         }

     }

     public void get() {
         lock.lock();
         try {
             while (products <= 0) {
                 System.out.println("商品库存没了");
                 try {
                     // 如果商品没了，阻塞线程，等待生产者线程生产完成后唤醒，
                     condition.await();
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
             System.out.println("消费了商品，剩余库存" + --products);
             condition.signalAll();
         } finally {
             lock.unlock();
         }

     }
 }

 // 生产者
 class Productor implements Runnable {
     private WareHouse wareHouse;

     public Productor(WareHouse wareHouse) {
         this.wareHouse = wareHouse;
     }

     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             try {
                 Thread.sleep(200);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             wareHouse.get();
         }
     }

 }

 // 消费者
 class Consumer implements Runnable {
     private WareHouse wareHouse;

     public Consumer(WareHouse wareHouse) {
         this.wareHouse = wareHouse;
     }

     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {

             wareHouse.set();
         }
     }

 }