说在前面的话：此篇实质是为了探讨ReentrantLock+Condition的应用场景，借用生产者消费者模型来解释。

重点实现线程间通信

juc之ReentrantLock+Condition，await、signal方法（对比）synchronized+Object的wait、notify。

ReentrantLock对比snchronized
ReentrantLock支持公平锁和非公平锁、可中断。

非公平锁（默认）
final ReentrantLock lock = new ReentrantLock();
final ReentrantLock lock = new ReentrantLock(false);
公平锁
final ReentrantLock lock = new ReentrantLock(true);

synchronized只支持非公平锁，不可中断。

Condition的await，signal对比Object的wait、notify
!!敲黑板!!
总有人拿定时来说事，但实际在jdk1.8版本上，都可以定时。看源代码好吧

这是Condition的
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;

这是Object的
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

await和wait的区别不是很大，关键在于ReentrantLock和synchronized的不同上。（关于await和wait属于个人所见，如果有错误，欢迎指点，谢谢）

接下来接分析下await和signal的使用状态。
在此之前，先看下我的生产者和消费者实现代码。

static class producerAndConsumer{

        boolean flag = false;
        Lock lock = new ReentrantLock();
        Condition producerCon = lock.newCondition();
        Condition consumerCon = lock.newCondition();

        public void producer(){
            lock.lock();
            if(flag){
                System.out.println("还有食物，暂时不需要生产");
                    try {
                        producerCon.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }
            flag = true;
            System.out.println("生产者生产了食物");
            consumerCon.signal();
            lock.unlock();
        }

        public void consumer(){
            lock.lock();
            if(!flag){
                System.out.println("没有食物了,通知生产者生产");
                try {
                    consumerCon.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("消费者进食中");
            flag = false;
            producerCon.signal();
            lock.unlock();
        }
    }

    public static void main(String []args) throws Exception{
        producerAndConsumer pac = new producerAndConsumer();
            new Thread(()->{
                for(int i=0;i<3;i++)
                pac.producer();
            }).start();

            new Thread(()->{
                for(int i=0;i<3;i++)
                pac.consumer();
            }).start();
    }

生产者和消费者之间的同步冲突，采用lock+Condition解决。
在定义好这两者之后，通过标志我们强化二者之间的同步标记。

在主函数中，我们对生产者和消费者各自调用三次。那么他们之间是如何同步的呢？

首先我们初始化两条线程后，这二者之间会有个竞争关系，也就是说，第一次的输出可能是消费者，也可能是生产者，各自50%的几率。

假如我们第一次是生产者拿到锁。
消费者竞争失败，触碰到lock，会进入线程进入了AQS（Abstract-Queue-Synchronized）抽象同步队列。

成功的生产者拿到锁，这时生产者会生产食物。
生产者然后通知消费者consumerCon.signal();，
生产者其次释放锁lock.unlock();释放锁
生产者立即重入（非公平锁）（注意我们一个线程有三次循环），但是这时会有标志提醒生产者
System.out.println(“还有食物，暂时不需要生产”);
producerCon.await();释放锁
此时生产者进入Condition，条件等待队列（显然是在等signal）

苦等多时的消费者终于可以吃上饭了。
获得锁后，吃完饭，重新进入与新的一轮，与生产者之间获取资源循环。

注释
非公平锁是可重入的，即在释放资源后，只需对计时器satus+1，即可重新获得锁。

公平锁，按照进入等待队列的时间来分配锁的使用，等待时间长的优先。