初步了解Condition执行过程

为了方便理解先看一段代码：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test01 {
    public static void main(String[] args) {
        final Business b = new Business();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    b.sub(i);
                }
            }

        }).start();
        for (int i = 1; i <= 50; i++) {
            b.main(i);
        }
    }

}

class Business {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    /*
     * 执行标志
     * true表示main执行
     * false表示sub执行
     */
    private boolean flag = true;

    public void main(int i) {
        lock.lock();
        while (!flag) {
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //flag为true时执行
        try {
            System.out.println("loop:" + i + "-" + "mainThread");
            condition.signal();
            flag = false;
        } finally {
            lock.unlock();
        }

    }

    public void sub(int i) {
        lock.lock();
        while (flag) {
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //flag为false时执行
        try {
            System.out.println("loop:" + i + "-" + "subThread");
            condition.signal();
            flag = true;
        } finally {
            lock.unlock();
        }
    }
}

这段代码的是实现让两个线程轮流执行的功能：
一段输出结果：

同步器AbstractQueuedSynchronizer（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的等待队列中来实现的唤醒操作。