J.U.C--locks--Condition

首先来解释一下Condition有什么作用：Condition的作用和Java原生的通过synchronized与wait()和nitofy()/notifyAll()方法相结合实现等待/通知模型的作用是一样的。Condition是一个多线程间协调通信的工具类。

我觉得有个博客写得很好：http://ifeve.com/understand-condition/ 看着这个博客基本就能理解了。

我们都知道synchronized与wait()和nitofy()/notifyAll()方法相结合可以实现等待/通知模型，也可以实现生产者消费者模型。ReentrantLock同样可以，但是需要借助Condition，且Condition有更好的灵活性，具体体现在：
1）一个Lock里面可以创建多个Condition实例，实现多路通知。

2）notify()方法进行通知时，被通知的线程时Java虚拟机随机选择的，但是ReentrantLock结合Condition可以实现有选择性地通知，这是非常重要的。

1. Condition接口中的常用方法

1） void await()造成当前线程在接到信号或被中断之前一直处于等待状态。2）boolean await(long time, TimeUnit unit)造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。3) long awaitNanos(long nanosTimeout)造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。4) void awaitUninterruptibly()造成当前线程在接到信号之前一直处于等待状态。5) boolean awaitUntil(Date deadline)造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。6) void signal() 唤醒一个等待线程。7) void signalAll() 唤醒所有等待线程。

实例与解析

下面通过一个使用的实例来说明问题：

package thread;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class ConditionDemo {    private static Lock lock = new ReentrantLock();    private static Condition condition = lock.newCondition();    public static void main(String[] args) {        Thread thread1 = new Thread(new Runnable(){            @Override            public void run() {                lock.lock();                System.out.println(Thread.currentThread().getName()+"正在运行。。。。");                try {                    Thread.sleep(2000);                    System.out.println(Thread.currentThread().getName()+"停止运行，等待一个signal");                    condition.await();//等待 并且会释放锁                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName()+"获得一个signal，继续执行");                lock.unlock();            }        },"waitThread");        thread1.start();        try {            Thread.sleep(1000);//保证线程1先执行，否则线程1将一直等待signal信号        } catch (InterruptedException e1) {            e1.printStackTrace();        }        Thread thread2 = new Thread(new Runnable(){            @Override            public void run() {                lock.lock();//获取锁                System.out.println(Thread.currentThread().getName()+"正在运行。。。。");                condition.signal();//发送信号，唤醒其它线程                System.out.println(Thread.currentThread().getName()+"发送一个signal");                System.out.println(Thread.currentThread().getName()+"发送一个signal后，结束");                lock.unlock();//释放锁之后,thread1再执行            }        },"signalThread");        thread2.start();    }}

运行结果：

从运行结果我们来分析：
1）当thread1拿到锁之后开始执行，当调用condition.await()方法之后，thread1开始睡眠并释放锁。这里thread1会释放锁，这个是一定要知道的，其实Condition的内部也是AQS实现的，也是通过AQS维护的队列释放锁。注意在线程1和线程2之间加一个延时，保证线程1先获取锁。

2）thread1开始睡眠并释放锁之后,thread2拿到锁，拿到锁之后开始运行，并调用condition.signal()发射一个信号来唤醒正在等待此条件condition的线程。 （注意，这里线程2调用signal函数之后，线程1还没有被唤醒，必须等线程2释放锁之后，线程1才能够恢复，）。发射信号之后thread2会继续执行，执行完毕后thread2释放锁。

3）当thread2释放锁之后，thread1拿到锁开始继续运行直至结束。

上面的逻辑更加详细的来说;
我们知道AQS自己维护的队列是当前等待资源的队列，AQS会在资源被释放后，依次唤醒队列中从前到后的所有节点，使他们对应的线程恢复执行。直到队列为空。

而Condition自己也维护了一个队列，该队列的作用是维护一个等待signal信号的队列，两个队列的作用是不同，事实上，每个线程也仅仅会同时存在以上两个队列中的一个，流程是这样的：

1. 线程1调用reentrantLock.lock时，线程被加入到AQS的等待队列中。

2. 线程1调用await方法被调用时，该线程从AQS中移除，对应操作是锁的释放。

3. 接着马上被加入到Condition的等待队列中，以为着该线程需要signal信号。

4. 线程2，因为线程1释放锁的关系，被唤醒，并判断可以获取锁，于是线程2获取锁，并被加入到AQS的等待队列中。

5. 线程2调用signal方法，这个时候Condition的等待队列中只有线程1一个节点，于是它被取出来，并被加入到AQS的等待队列中。 注意，这个时候， 线程1 并没有被唤醒。

6. signal方法执行完毕，线程2调用reentrantLock.unLock()方法，释放锁。这个时候因为AQS中只有线程1，于是，AQS释放锁后按从头到尾的顺序唤醒线程时，线程1被唤醒，于是线程1回复执行。

7. 直到释放所整个过程执行完毕。

可以看到，整个协作过程是靠结点在AQS的等待队列和Condition的等待队列中来回移动实现的，Condition作为一个条件类，很好的自己维护了一个等待信号的队列，并在适时的时候将结点加入到AQS的等待队列中来实现的唤醒操作。