前言：对于线程通信，使用synchronized时使用wait、notify和notifyAll来实行线程通信。而使用Lock如何处理线程通信呢?答案就是本片的主角:Condition.
一、Condition
Condition，Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
1，Codition接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用Object.wait访问的隐式监视器类似。
但提供了更强大的功能，需要指出的是，单个lock可能与多个condition对象关联。为了避免兼容性问题，condition方法的名称与对应的object版本中不一样。
2，在condition对象中，与wait，notify，notifyAll方法对应的分别是await，signal，和signalAll。
3，condition实例实质上是被绑定到了一个锁上，要为特定Lock实例获得condition实例，请使用newCondition（）方法。
生产者与消费者程序中，这里通过Lock和condition来联合处理，代替synchronized和wait方法：
/*
* 生产者消费者案例：
*/
public class TestProductorAndConsumerForLock {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor pro = new Productor(clerk);
Consumer con = new Consumer(clerk);
new Thread(pro, "生产者 A").start();
new Thread(con, "消费者 B").start();
new Thread(pro, "生产者 C").start();
new Thread(con, "消费者 D").start();
}
}
class Clerk {
private int product = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
// 进货
public void get() {
// 锁住
lock.lock();
try {
// 为了避免虚假唤醒，应该总是使用在while循环中。
while (product >= 1) {
System.out.println("产品已满！");
try {
condition.await();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : "
+ ++product);
condition.signalAll();
} finally {
// unlock放在finally中，可确保一定会锁被释放
lock.unlock();
}
}
// 卖货
public void sale() {
lock.lock();
try {
// 为了避免虚假唤醒，应该总是使用在while循环中。
while (product <= 0) {
System.out.println("缺货！");
try {
condition.await();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : "
+ --product);
condition.signalAll();
} finally {
lock.unlock();
}
}
}
// 生产者
class Productor implements Runnable {
private Clerk clerk;
public Productor(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.get();
}
}
}
// 消费者
class Consumer implements Runnable {
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
clerk.sale();
}
}
}
在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。
二、Conditon的常用方法
Condition底层模型:
（1）await()
这个方法由当前获得锁的线程调用，意思是释放锁，挂起自己并且唤醒等待当前线程持有的锁的其他线程（在aqs的等待队列中的其他节点），类似于synchronized同步代码块的wait方法的意思。
源码分析：
public final void await() throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// 这个方法是将当前线程放到当前condition的队列中
Node node = addConditionWaiter();
// 释放当前线程站有的锁
int savedState = fullyRelease(node);
int interruptMode = 0;
//isOnSyncQueue的意思是判断当前的线程是否在sync的队列（sync的队列就是aqs的队列）
//while循环的意思是只要封装当前线程的node没有在aqs的队列中，就一直循环。
while (!isOnSyncQueue(node)) {
// 将当前的线程挂起，也就是说等当前的线程获得锁之后，还是从这里开始运行
LockSupport.park(this);
// 这里是判断在线程挂起的时间内，有没有别的线程调用这个线程的iterrupt方法，如果没有的话返回0
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
//挂起结束，也就是重新运行之后，调用acquireQueued方法，即进入aqs的队列中，acquireQueued方法就是获取锁的代码，如果获取失败则被挂起。
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
await方法，其实就是先释放锁(说白了底层就是更改了AQS的state),然后调用LockSupport的park方法park自己，再把自己丢进Condition的等待队列中。这里不要忘记了，释放锁的同时还通知了同步队列中的线程去拿锁哦。
（2）signal()
思想：将在condition的wait queue中等待的线程转移到aqs的队列中。
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
//firstwaiter就是condition的队列中的head
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
} while (!transferForSignal(first) &&//transferForSignal的意思就是转移first节点到aqs的队列中。
(first = firstWaiter) != null);//直到转移成功first或者队列中没有节点
}
final boolean transferForSignal(Node node) {
/* If cannot change waitStatus, the node has been cancelled. */
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))//将node的waitStatus设置为0，如果设置失败，返回false，继续进行操作，设置成功向下走。
return false;
Node p = enq(node);//enq之前说过了，是将其加入到aqs的队列中
int ws = p.waitStatus;
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))//将node的waitStatus设置为signal，这样在aqs的队列中就和普通的等待着一样了。
LockSupport.unpark(node.thread);
return true;
}
signal()底层模型：
通过signla方法，之前在condition的等待队列中的线程的head已经转移到aqs的队列中去等待获得锁了。
举个例子更好的理解（多个生产者和多个消费者的例子）：
生产者生产商品，消费者消费商品，生产出的商品放到容器中，容器中只能放一个商品。刚上来容器中为空，假设消费者获得锁，则所有的消费者在叫做empty的condition上等待，同时释放锁，这时，可能有一个或者多个消费者在empty上等待。此时生产者获得锁（因为只要是消费者获得锁就会进入empty的condition的队列中），将生产的商品放入到容器中，此时容器中已经有商品，其他的生产者发现不能放了，则在full这个condition上等待，也就是进入full这个condition的队列中，生产者放入后，会调用empty.signal，意思是将在empty中等待的线程转移到aqs的队列中，准备获得锁，然后生产者释放所， 消费者获得锁（因为现在容器中有商品了，虽然生产者有机会获得锁，但是只要是生产者持有锁，就会调用full.await，也就是现在条件不满足，虽然我获得了锁，但是必须要等待消费者消费，于是进入full的队列中，所以最终是消费者获得锁）。消费者获得锁后将商品消费，然后调用full.signal，也就是通知生产者生产，这样就回到了最开始的时候.....
condition基本原理就是内部维持了一个队列，在调用await的时候将线程阻塞，释放锁，将其加入到队列中等待，在调用signal的时候将自己队列中的head转移到aqs的队列中，等待获得锁。
参考链接
本文主要整理自互联网，主要是便于自己复习知识所用，侵权联系删除，以下为原文参考链接！