学习的是这篇文章 https://blog.csdn.net/heyutao007/article/details/49889849
Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。
为啥更安全和高效呢？
简单说，他的作用是使得某些线程一起等待某个条件（Condition），只有当该条件具备(signal 或者 signalAll方法被调用)时，这些等待线程才会被唤醒，从而重新争夺锁。
感觉就是说这个线程，它原来是想要获取这个锁的，但是时机未到， 先不去抢这个锁，然后时机到了，就去抢锁了。
Condition是个接口，基本的方法就是await()和signal()方法；
它的实现是哪个呢？AbstractQueuedSynchronizer里面的ConditionObject
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用
Conditon中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()。
Object里面的这个wait(),这个notify(),这个notifyAll()怎么使用呢？
例子：
package com.study.controller;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class TestCondition {
public static void main(String[] args) {
final ReentrantLock reentrantLock = new ReentrantLock();
final Condition condition = reentrantLock.newCondition();
new Thread(new Runnable() {
@Override
public void run() {
reentrantLock.lock();
System.out.println(Thread.currentThread().getName() + "拿到锁了");
System.out.println(Thread.currentThread().getName() + "等待信号");
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到信号");
System.out.println(Thread.currentThread().getName() + "释放锁");
reentrantLock.unlock();
}
}, "线程1").start();
new Thread(new Runnable() {
@Override
public void run() {
reentrantLock.lock();
System.out.println(Thread.currentThread().getName() + "拿到锁了");
try {
System.out.println(Thread.currentThread().getName() + "拿到锁后，sleep 3000");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "发出信号");
condition.signalAll();
try {
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + "发出信后，sleep 3000");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "释放锁");
reentrantLock.unlock();
}
}, "线程2").start();
}
}
结果是线程1先拿到锁，然后await（await会释放锁)了，线程2就能获取到锁了，
线程2signalAll了后，又sleep了3s，然后释放锁，线程1在线程2释放锁之后才
拿到信号，说明signalAll（所有线程都能在锁被释放后，拿到这个锁）后，别的线程需要在这个锁完全空出来之后，才能拿到这个信号(就是拿到了这个锁),然后去获取这个锁。
假设把线程2的condition.signalAll();删除掉，线程1就拿不到锁了。
如果有三个线程，两个线程拿到锁之后await，最后一个线程拿到锁之后notify一下，释放锁，那么await的两个线程，只会有一个线程拿到锁，另外一个线程就会惨惨的等着notify。
public interface Condition {
//使当前线程加入 await() 等待队列中，并释放当锁，当其他线程调用signal()会重新请求锁。与Object.wait()类似。
void await() throws InterruptedException;
//调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。
//调用该方法后，结束等待的唯一方法是其它线程调用该条件对象的signal()或signalALL()方法。等待过程中如果当前线程被中断，该方法仍然会继续等待，同时保留该线程的中断状态。
void awaitUninterruptibly();
// 调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。
//nanosTimeout指定该方法等待信号的的最大时间（单位为纳秒）。若指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间；
//若指定时间内有其它线程中断该线程，则抛出InterruptedException并清除当前线程的打断状态；若指定时间内未收到通知，则返回0或负数。
long awaitNanos(long nanosTimeout) throws InterruptedException;
//与await()基本一致，唯一不同点在于，指定时间之内没有收到signal()或signalALL()信号或者线程中断时该方法会返回false;其它情况返回true。
boolean await(long time, TimeUnit unit) throws InterruptedException;
//适用条件与行为与awaitNanos(long nanosTimeout)完全一样，唯一不同点在于它不是等待指定时间，而是等待由参数指定的某一时刻。
boolean awaitUntil(Date deadline) throws InterruptedException;
//唤醒一个在 await()等待队列中的线程。与Object.notify()相似
void signal();
//唤醒 await()等待队列中所有的线程。与object.notifyAll()相似
void signalAll();
}
