前言
在BlockingQueue队列中，每当我们put和take元素时，当队列满时或空时，各自会阻塞，而这个阻塞方用的是Condition接口的await();与我们平时直接用Object的wait方法和notify方法大同小异，我将通过源码和一些例子来分析Condtion用法和它与Object的wait、notify之间的区别和各自的优点。
在JDK源码中有段解释是：
The key property that waiting for a condition provides is that it atomically releases the associated lock and suspends the current thread, just like Object.wait
Condition执行等待（阻塞）方法提供的关键属性是，它会原子地释放相关的锁，并挂起当前线程，就像object.wait一样。
由于Condition是一个接口，而实现这个接口的ConditionObject又是AbstractQueuedLongSynchronizer抽象类的内部类，所以，得到这个ConditionObject实例并不能直接newCondition，而是配合着AbstractQueuedLongSynchronizer方法使用，所以理解这层关系成了理解Condition的关键。
简单用法
下面是模拟Blockqueue写的一个关于Condition的用法，关于BlockQueue，大家可以参考java基础：java.util.concurrent.BlockingQueue，用法与wait和notify类似。
创建一个队列，生产者往队列里put元素，如果队列已满，则阻塞，无法继续添加数据。然后再有一个消费者取数据，每取出一个数据，就用Condition.signal()方法唤醒阻塞方法，让生产者可以继续put元素。
当队列为空时，再取元素就会开成阻塞，当再有生产者往队列里加数据时，也会唤醒取数据的阻塞方法。这样就形成了带阻塞的数据模型。
package com.company.condition;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* Created by wxwall on 2017/5/31.
*/
public class ConditionDemo {
public static void main(String[] args) throws InterruptedException {
//创建一个队列
Queue queue = new Queue(3);
//创建一个生产者，往队列里put数据
Produce produce = new Produce(queue);
Thread t = new Thread(produce);
t.start();
//Thread.sleep(3000);
//创建一个消费者，用来取数据
Consumer consumer = new Consumer(queue);
Thread t1 = new Thread(consumer);
t1.start();
}
static class Produce implements Runnable{
Queue q = null;
public Produce(Queue queue){
this.q = queue;
}
@Override
public void run() {
try {
long begin = System.currentTimeMillis();
for (int i = 0;i<10;i++){
q.put(new String("aa"));
q.put(new String("bb"));
q.put(new String("cc"));
}
System.out.println("耗时：" + (System.currentTimeMillis() - begin));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class Consumer implements Runnable{
Queue q = null;
public Consumer(Queue queue){
this.q = queue;
}
@Override
public void run() {
try {
for (int i = 0 ;i<10;i ++){
Object obj1 = q.take();
Object obj2 = q.take();
Object obj3 = q.take();
System.out.println((String)obj1.toString() + " " + (String)obj2.toString() + " " + (String)obj3.toString());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 创建一个简单的数组队列
*/
private static class Queue {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Object obj [] = null;
private int size = 0;
private int consInt = 0;
public Queue(Integer obj){
this.obj = new Object[obj];
}
//往队列里加数据
public void put(Object obj) throws InterruptedException {
//获得锁
lock.lock();
try {
if(size > this.obj.length -1){
//如果队列满了就阻塞
condition.await();
}
this.obj[size] = obj;
size ++;
//如果队列空了，添加元素后要通知take，唤醒condition
condition.signal();
}finally {
lock.unlock();
}
}
public Object take(){
lock.lock();
try{
if(size == 0 ){
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Object obj = this.obj[size - 1];
size --;
condition.signal();
return obj;
}finally {
lock.unlock();
}
}
}
}
执行结果（因为没有用链表实现队列，所以结果并不是FIFO形式）
cc bb aa
cc bb aa
cc bb aa
cc bb aa
cc bb aa
cc bb aa
aa aa cc
cc bb bb
cc bb aa
cc bb aa
耗时：1
另外注意的一点是，BlockingQueue的实现ArrayBlockingQueue的put方法和take方法，分别用的是两个不同的condition实例，源码如下：
/** Condition for waiting takes */
private final Condition notEmpty;
/** Condition for waiting puts */
private final Condition notFull;
上面代码模型如图所示：
下面用实现一个简单的wait、notify模型
package com.company.condition;
import java.util.concurrent.locks.Condition;
/**
* Created by wxwall on 2017/5/29.
*/
public class ConditionTest {
public static void main(String[] args) throws InterruptedException {
Condition condition;
Integer a = 2;
Thread t1 = new Thread(new ThreadCondition(a));
Thread t2 = new Thread(new ThreadCondition(a));
t1.start();
t2.start();
}
public static class ThreadCondition implements Runnable{
Integer a = 0;
public ThreadCondition(Integer a){
this.a = a;
}
@Override
public void run() {
try {
int i = 0;
while(i < 3){
synchronized (a){
a.notify();
System.out.println(Thread.currentThread().getName());
a.wait();
System.out.println("wait被唤醒");
}
i++;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
下面是输出结果：
Thread-0
Thread-1
wait被唤醒
Thread-0
wait被唤醒
Thread-1
wait被唤醒
Thread-0
wait被唤醒
Thread-1
wait被唤醒
与notify、wait方法的区别
Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
在同一个monitor中Conditioin可以存在多个实例，在生产者和消费者模型里比较常见。
而wait，notify和notifyAll必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）
wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。
调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）
调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；
调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；
JDK原文整理如下
Condition 实现可以提供不同于 Object 监视器方法的行为和语义，比如受保证的通知排序，或者在执行通知时不需要保持一个锁。如果某个实现提供了这样特殊的语义，则该实现必须记录这些语义。
注意，Condition 实例只是一些普通的对象，它们自身可以用作 synchronized 语句中的目标，并且可以调用自己的 wait 和 notification 监视器方法。获取 Condition 实例的监视器锁或者使用其监视器方法，与获取和该 Condition 相关的 Lock或使用其 waiting和 signalling 方法没有什么特定的关系。为了避免混淆，建议除了在其自身的实现中之外，切勿以这种方式使用 Condition 实例。
为何这三个不是Thread类声明中的方法，而是Object类中声明的方法（当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法）？
由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。
