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();
        }
    }
}