一.Condition是什么
关键字synchronize可以与wait()和nitify()方法相结合实现实现等待/通知模式，类ReentrantLock也可以实现同样的功能，但需要借助condition对象。
Java里 sychronized和Lock+Condtion 都属于管程模型，Condition 在管程模型中代表的就是等待的条件。
在Java1.5之前，线程之间的通信主要通过notify和wait。而Condition支持多路等待，就是定义多个Condition，每个Condition控制一个支路，典型问题生产者和消费者问题现在可以通过这个接口来进行优化。
condition类是在JDK5中出现的技术，使用他有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里可以创建多个condition实例，
线程对象可以注册在指定的condition中从而选择性的进行线程通知，在调度线程上更加灵活。
而在使用notify()/notifuAll()方法进行通知时，被调度的线程却是由JVM随机选择的。但使用ReentrantLock结合condition类是可以实现上面讲的“选择性通知”，
这个功能是非常重要的，而且在condition类中默认提供的。而synchronize就相当于整个Lock对象中只有一个单一的condition对象，所有的线程都注册在它一个对象上。
线程开始notifyAll()时，需要通知所有的WAITING线程，没有选择权，会出现相当大的效率问题。
Condition在Lock的基础上使用，在原来Lock的基础上实现了可以基于多种条件来让线程实现同步的效果增加了多个条件后，我们可以更有针对性，也更灵活的协调多种条件下的线程协调。
二.Condition能做什么
（1）condition能实现线程之间的通信，和wait,notify实现的功能是一样的，但是condition更为强大，也更为灵活。
例子：我们知道notify是否无法叫醒哪一个线程（而是随机叫醒一个线程），而condition就能做到叫醒特定的一个线程。
（2）condition接口，它的实现有conditionObject ,而conditionObject是依附于AQS,是AQS的一个内部类。
（3）同步队列
当多线程环境下，在使用锁中，当没有拿到锁的线程，都会被扔进同步队列中。
等待队列。同步队列是等待抢占cpu时间片，一旦调用了wait方法或await方法，都会加入到等待队列中。
在等待队列中，是一定要被叫醒就可以。没机会去抢占cpu时间片。每一个Condition对象中都有一个由链表组成的等待队列。
（4）JUC中的Condition中await()、signal()、signalAll()分别对应Object中的wait()、notify()、notifyAll()方法。
三.Condition原理
ConditionObject是同步器AbstractQueuedSynchronizer的内部类，因为Condition的操作需要获取相关联的锁，所以作为同步器的内部类也较为合理。
每个Condition对象都包含着一个队列（以下称为等待队列），该队列是Condition对象实现等待/通知功能的关键。
下面将分析Condition的实现，主要包括：等待队列、等待和通知，下面提到的Condition如果不加说明均指的是ConditionObject。
1、等待队列
等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程，
如果一个线程调用了Condition.await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。
事实上，节点的定义复用了同步器中节点的定义，也就是说，同步队列和等待队列中节点类型都是同步器的静态内部类AbstractQueuedSynchronizer.Node。
一个Condition包含一个等待队列，Condition拥有首节点（firstWaiter）和尾节点（lastWaiter）。
当前线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队列，等待队列的基本结构如图所示。
如图所示，Condition拥有首尾节点的引用，而新增节点只需要将原有的尾节点nextWaiter指向它，并且更新尾节点即可。
上述节点引用更新的过程并没有使用CAS保证，原因在于调用await()方法的线程必定是获取了锁的线程，也就是说该过程是由锁来保证线程安全的。
在Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而并发包中的Lock（更确切地说是同步器）拥有一个同步队列和多个等待队列，其对应关系如图所示。
如上图所示，Condition的实现是同步器的内部类，因此每个Condition实例都能够访问同步器提供的方法，相当于每个Condition都拥有所属同步器的引用。
2、等待
调用Condition的await()方法（或者以await开头的方法），会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。
当从await()方法返回时，当前线程一定获取了Condition相关联的锁。
如果从队列（同步队列和等待队列）的角度看await()方法，当调用await()方法时，相当于同步队列的首节点（获取了锁的节点）移动到Condition的等待队列中。
Condition的await()方法，如下代码所示：
public final void await() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); // 当前线程加入等待队列 Node node = addConditionWaiter(); // 释放同步状态，也就是释放锁 int savedState = fullyRelease(node); int interruptMode = 0; while (!isOnSyncQueue(node)) { LockSupport.park(this); if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; } if (acquireQueued(node, savedState) && interruptMode != THROW_IE) interruptMode = REINTERRUPT; if (node.nextWaiter != null) unlinkCancelledWaiters(); if (interruptMode != 0) reportInterruptAfterWait(interruptMode); }
调用该方法的线程成功获取了锁的线程，也就是同步队列中的首节点，该方法会将当前线程构造成节点并加入等待队列中，然后释放同步状态，唤醒同步队列中的后继节点，然后当前线程会进入等待状态。
当等待队列中的节点被唤醒，则唤醒节点的线程开始尝试获取同步状态。如果不是通过其他线程调用Condition.signal()方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException。
如果从队列的角度去看，当前线程加入Condition的等待队列，该过程如图示。
如上图所示，同步队列的首节点并不会直接加入等待队列，而是通过addConditionWaiter()方法把当前线程构造成一个新的节点并将其加入等待队列中。
3、通知
调用Condition的signal()方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中。
Condition的signal()方法，如代码如下所示：
public final void signal() { if (!isHeldExclusively()) throw new IllegalMonitorStateException(); Node first = firstWaiter; if (first != null) doSignal(first); }
调用该方法的前置条件是当前线程必须获取了锁，可以看到signal()方法进行了isHeldExclusively()检查，也就是当前线程必须是获取了锁的线程。
接着获取等待队列的首节点，将其移动到同步队列并使用LockSupport唤醒节点中的线程。
节点从等待队列移动到同步队列的过程如图所示。
通过调用同步器的enq(Node node)方法，等待队列中的头节点线程安全地移动到同步队列。当节点移动到同步队列后，当前线程再使用LockSupport唤醒该节点的线程。
被唤醒后的线程，将从await()方法中的while循环中退出（isOnSyncQueue(Node node)方法返回true，节点已经在同步队列中），进而调用同步器的acquireQueued()方法加入到获取同步状态的竞争中。
成功获取同步状态（或者说锁）之后，被唤醒的线程将从先前调用的await()方法返回，此时该线程已经成功地获取了锁。
Condition的signalAll()方法，相当于对等待队列中的每个节点均执行一次signal()方法，效果就是将等待队列中所有节点全部移动到同步队列中，并唤醒每个节点的线程。
四.Condition的使用
生产者-消费者模式是一个十分经典的多线程并发协作的模式，弄懂生产者-消费者问题能够让我们对并发编程的理解加深。
所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据，
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；
而消费者只需要从共享数据区中去获取数据，就不再需要关心生产者的行为。但是，这个共享数据区域中应该具备这样的线程间并发协作的功能：
（1）如果共享数据区已满的话，阻塞生产者继续生产数据放置入内；
（2）如果共享数据区为空的话，阻塞消费者继续消费数据；
使用Lock的Condition的await/signal的消息通知机制实现生产者和消费者的功能：
代码如下：
package com.sunny.jdk.concurrent.condition.app; import java.util.LinkedList; import java.util.List; import java.util.Random; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * <Description> 使用Condition的wait和signal实现消费者和生产者相互通知的功能<br>*/ public class ProducerConsumerApp {
private static ReentrantLock lock = new ReentrantLock(); private static Condition full = lock.newCondition(); private static Condition empty = lock.newCondition(); public static void main(String[] args) { LinkedList linkedList = new LinkedList(); ExecutorService service = Executors.newFixedThreadPool(15); for (int i = 0; i < 5; i++) { service.submit(new Producer(linkedList, 8, lock)); } for (int i = 0; i < 10; i++) { service.submit(new Consumer(linkedList, lock)); } } static class Producer implements Runnable { private List<Integer> list; private int maxLength; private Lock lock; public Producer(List list, int maxLength, Lock lock) { this.list = list; this.maxLength = maxLength; this.lock = lock; } @Override public void run() { while (true) { lock.lock(); try { while (list.size() == maxLength) { System.out.println("生产者" + Thread.currentThread().getName()+ " list以达到最大容量【" + maxLength + "】，进行wait"); full.await(); System.out.println("生产者" + Thread.currentThread().getName() + " 退出wait"); } Random random = new Random(); int i = random.nextInt(); System.out.println("生产者" + Thread.currentThread().getName() + " 生产数据" + i); list.add(i); empty.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } } static class Consumer implements Runnable { private List<Integer> list; private Lock lock; public Consumer(List list, Lock lock) { this.list = list; this.lock = lock; } @Override public void run() { while (true) { lock.lock(); try { while (list.isEmpty()) { System.out.println("消费者" + Thread.currentThread().getName() + " list为空，进行wait"); empty.await(); System.out.println("消费者" + Thread.currentThread().getName() + " 退出wait"); } Integer element = list.remove(0); System.out.println("消费者" + Thread.currentThread().getName() + " 消费数据：" + element); full.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } } }
五.总结：
调用condition的await()方法后，会将当前线程加入到等待队列中，然后释放锁，然后循环判断节点是否在同步队列中，再获取锁，否则一直阻塞。
调用signal()方法后，先判断当前线程是否有锁，然后调用doSignal()方法，并唤醒线程，被唤醒的线程，再调用acquireQueude()方法，重新开始竞争锁，得到锁后返回，退出该方法。
Condition它用来替代传统的Object的wait()、notify()实现线程间的协作。相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。
调用Condition的await()和signal()方法，都必须在lock保护之内。
Conditon中的await()对应Object的wait()，Condition中的signal()对应Object的notify()，Condition中的signalAll()对应Object的notifyAll()。wait和notify是和synchronized关键字配合使用的。