java多线程 生产者和消费者 lock

 package com.atguigu.thread.lock;

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

 /*
  * 小米厂家：
  * 库房有限，只能存10台小米电视
  * 工人的生产电视与销售的卖电视同时进行
  * 当工人生产电视把库房存满了，要求工人休息，直到销售卖出至少一台电视，库房可以再次电视，然后他再次开始生产
  * 当销售者把库房的电视都卖完了，要求销售者休息，直到工人生产了至少一台电视，销售才继续卖电视
  *
  * 工人是一个线程
  * 销售是一个线程
  *
  * 需要线程的通信：当工人休息后，销售组销售了电视，应该告知工人一声，可以继续生产了
  *            当销售休息后，工人如果生产了电视，应该通知销售，可以开始卖电视了
  *
  * 问题：
  * （1）因为共享num变量，所以有线程安全问题：依靠同步解决
  * （2）因为库房有限：线程通信  wait,notify
  *
  * 涉及到的方法：
  * （1）wait：等待
  * （2）notify/notifyAll：通知
  *
  * 这两个方法必须由“锁”对象来调用
  * “锁”对象，必须是多个线程共享的锁对象
  *
  * 如果是多个工人，多个销售者
  *
  * synchronized：隐式锁
  * wait
  * notify/notifyAll
  *
  * 如果使用Lock锁，那么线程通信应该使用Condition来解决通信
  * 条件.await()：某种条件，等待
  * 条件.signal()：某种条件唤醒
  *
  */
 public class TestTongXin {

     public static void main(String[] args) {
         Houseware h = new Houseware();

         Worker w1 = new Worker(h);
         Worker w2 = new Worker(h);
         Saler s1 = new Saler(h);
         Saler s2 = new Saler(h);

         w1.start();
         w2.start();
         s1.start();
         s2.start();
     }

 }
 class Houseware{
     private static final int MAX_VALUE = 10;
     private int num = 0;
     private Lock lock = new ReentrantLock();
     private Condition full = lock.newCondition();
     private Condition empty = lock.newCondition();

     //往里放电视
     public void add(){
         lock.lock();
         if(num>=MAX_VALUE){
             try {
                 full.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }else{
             num++;
             try {
                 Thread.sleep(100);//为了问题暴露的明显一点
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println("工人生产了一台电视，现在库存是：" + num);
 //            empty.signal();
             empty.signalAll();
         }

         lock.unlock();
     }

     //往外拿电视
     public void take(){
         lock.lock();
         if(num<=0){
             try {
                 empty.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }else{
             num--;
             try {
                 Thread.sleep(100);//为了问题暴露的明显一点
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println("销售卖了一台电视，现在库存是：" + num);
             full.signalAll();
         }

         lock.unlock();
     }
 }

 class Worker extends Thread{
     private Houseware h;

     public Worker(Houseware h) {
         super();
         this.h = h;
     }

     public void run(){
         //往仓库放电视
 //        库房.add();
         while(true){
             h.add();
         }
     }
 }
 class Saler extends Thread{
     private Houseware h;

     public Saler(Houseware h) {
         super();
         this.h = h;
     }

     public void run(){
         while(true){
             h.take();
         }
     }
 }