基于Lock下的线程通信

//基于Lock下的线程通信
public class TestA {
    public static void main(String[] args) {

        Product product = new Product();
        //创建生产者对象
        //producer producer = new producer(product);
        //创建消费者对象
        //consumer consumer = new consumer(product);
        //创建Lock对象,父类引用指向子类,多态
        Lock lock = new ReentrantLock();
        //创建生产者对列
        Condition producerCondition = lock.newCondition();
        //创建消费者对列
        Condition consumerCondition = lock.newCondition();

        //将生产者添加的线程中
         new Thread(new producer(product,lock,producerCondition,consumerCondition)).start();
        //将消费者添加的线程中
        new Thread(new consumer(product,lock,producerCondition,consumerCondition)).start();


        //new Thread(new producer(product)).start();
        //new Thread(new producer(product)).start();
    }
}
//生产者线程
class producer implements Runnable{
    static int num =0;
    private Product product;
    private Lock lock;
    private Condition producerCondition;  //生产者等待对列
    private Condition consumerCondition;  //消费者等待对列
    //添加构造方法保证是同一个对象
    public producer(Product product,Lock lock,Condition producerCondition,Condition consumerCondition){
        this.product=product;
        this.lock =lock;
        this.producerCondition =producerCondition;
        this.consumerCondition =consumerCondition;
    }
    @Override
    public void run() {
        while (true){
                lock.lock();  //关锁
                if (product.isFlag()){   //如果为true代表里面有产品
                    try {
                        producerCondition.await();  //等待,Condition特有方法
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }                         //当前库存没有的时候,开始生产
                if (num%2==0){
                    product.setColor("白色");
                    try {
                        //休眠
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    product.setName("馒头");
                }else {
                    product.setColor("黄色");
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    product.setName("玉米饼");
                }
                System.out.println("生产者生产了"+product.getColor()+"--"+product.getName());
                product.setFlag(true);  //代表生产者里面有产品
                consumerCondition.signal(); //让消费者来消费即可,Condition特有方法
                lock.unlock(); //开锁
                num++;
            }

        }
}

//消费者线程
class consumer implements Runnable{

    private Product product;
    private Lock lock;
    private Condition producerCondition;  //生产者等待对列
    private Condition consumerCondition;  //消费者等待对列
    public consumer(Product product,Lock lock,Condition producerCondition,Condition consumerCondition){
        this.product=product;
        this.lock =lock;
        this.producerCondition =producerCondition;
        this.consumerCondition =consumerCondition;
    }
    @Override
    public void run() {
        while (true){
            lock.lock();
            if (!product.isFlag()){  //如果得到的值为false,代表生产者没有产品
                try {
                    consumerCondition.await();  //等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("消费者消费了"+product.getColor()+"--"+product.getName());
            product.setFlag(false); //代表生产者没有产品
            producerCondition.signal();  //让生产者生产产品
            lock.unlock();
            }
        }
}