并发编程的艺术之读书笔记（九）

前言：

上一部分，我们一起学习了可重入锁和读写锁，这部分我们来一起学习Condition接口

所有的java对象， 都默认有一组监视器方法，包括wait()，wait(long timeout)，notify()，notifyAll()，这些方法和synchronized关键字配合，可以实现通知/等待模式。Condition接口也提供类似方法，与Lock接口配合也可以实现通知/等待模式，Condition接口的await()方法对应Object的wait()犯法，singnal()方法对应notify()方法，singalAll()方法对应notifyAll()方法。

1. Condition接口与示例

Condition对象是由Lock对象创建出来的，Condition的使用需要和Lock进行绑定，而一个Lock对象可以绑定多个Condition对象，接下来用个简单的例子来演示一下Condition中等待和通知方法的使用

Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();
    public void conditionalWait() throws InterruptedException {
        lock.lock();
        try {
            condition.await();
        }finally {
            lock.unlock();
        }
    }
    
    public void conditionalSignal(){
        lock.lock();
        try {
            condition.signal();
        }finally {
            lock.unlock();
        }
    }

可以看到，一般都把Condition对象作为成员变量，调用await()方法后，线程会释放锁并在此等待，其他线程调用signal()方法，通知当前线程后，当前线程获取锁并从await()返回。

Condition的常用方法及描述如下

方法名称	描述
final void await() throws InterruptedException	当前线程进入等待状态直到被通知（signal）或中断，当前线程将进入运行状态
final void awaitUninterruptibly()	当前线程进入等待状态直到被通知，对中断不敏感
final void signal()	唤醒一个等待在Condition上的线程，该线程从等待方法返回前必须获得与Condition相关联的锁
final void signalAll()	唤醒所有等待在Condition上的线程，该线程从等待方法返回前必须获得与Condition相关联的锁

获取一个Condition必须通过Lock的newCondition方法。

接下来我们分析Condition的实现

ConditionObject时同步器AQS的内部类，Condition接口由ConditionObject实现。每个Condition对象都包含一个队列（等待队列），该队列是实现等待/通知功能的关键。

1. 等待队列

等待队列是一个FIFO队列，在队列中每一个节点都包含一个线程引用，该线程就是在Condition对象上等待的线程，如果一个线程调用了Condition.await()方法，那么该线程将会释放锁，构造成节点加入等待队列并进入等待状态。事实上，节点的定义复用了同步器中节点的定义（同步队列和等待队列的节点类型都是同步器中的静态内部类Node）。

一个Condition包含一个等待队列，Condition拥有首节点和尾节点，节点源码如下

/** First node of condition queue. */
        private transient Node firstWaiter;
        /** Last node of condition queue. */
        private transient Node lastWaiter;

当前线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队列，等待队列基本结构如图所示。

Condition拥有首位节点的引用，新增节点只要将原有的尾节点nextWaiter指向它，并且更新尾节点即可。更新引用的过程并没有用CAS来保证，因为调用await()就必定获取了锁，所以这个过程用锁来保证了线程安全。

在Object的监视器模型上，一个对象同时拥有一个同步队列和一个等待队列，Lock则拥有一个同步队列和多个等待队列，对应关系图如下所示

如图所示，每个Condition都拥有所属同步器的引用。

2. 等待

调用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) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

调用该方法的线程成功获取了锁的线程，也就是同步队列中的首节点，该方法会将当前线程构造成节点并加入等待队列中， 然后释放同步状态，唤醒同步队列中的后继节点，然后当前线程会进入等待状态。

等待队列中的节点被唤醒，则唤醒节点的线程开始尝试获取同步状态。如果不是通过其他线程调用Condition.singal()方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException.

3. 通知

通知Condition的signal()方法，将会唤醒在等待队列中等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将系欸但移到同步队列中。

public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

调用该方法的前置条件是当前线程必须获取了锁，可以看到singal()方法进行了isHeldExclusively()判断，判断当前线程是否是获取锁的线程。接着获取等待队列的首节点，将其移动到同步队列并用LockSupport唤醒节点中的线程，节点从等待队列移动到同步队列的过程如下图所示

被唤醒后的线程，将从await()方法中的while循环中退出，嗲用同步器的acquireQueued()方法加入到获取同步状态的竞争中。

成功或同步状态后被唤醒的线程将从先前调用await()方返回，此时该线程已经成功地获取了锁。Condition的signalAll()方法，相当于对等待队列中的每一个节点都执行一次signal()方法，效果就是将等待队列中所有的节点都移到同步队列中，并唤醒每个节点的线程。

总结

这一部分，我们一起学习了Condition接口，了解了Condition接口中的方法与Object中通知唤醒方法的区别，下一部分，我们将一起学习ConcurrentHashMap的内容。