Java并发编程之Condition

什么是Condition

Condition出现于java 1.5，主要用于实现线程间通信，用来替代传统的Object的wait()、notify()实现线程间的协作。与原来的方法相比，Condition提供的await()、signal()更为安全和高效，下面我们一起来走进Condition的学习吧。

注意点：

• Condition实际上是一个接口，基本方法为await()方法和signal()方法
• Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()；
• 调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

对Condition的源码分析

实际上，每个Condition对象都维护一个等待队列（单向队列）。等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程。如果一个线程调用了Condition.await()方法，那么该线程将会释放锁，构造节点并加入等待队列。AQS有一个同步队列和多个等待队列，节点都是Node。

每个Condition对象中保存了firstWaiter和lastWaiter作为队列首节点和尾节点，每个节点使用Node.nextWaiter保存下一个节点的引用。

Condition.await()

		public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter(); //构造一个新的等待队列Node加入到队尾
            int savedState = fullyRelease(node); //释放当前线程的独占锁，不管重入几次，都把state释放为0
            int interruptMode = 0;
            //如果当前节点没有在同步队列上，即还没有被signal，则将当前线程阻塞
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                //区分两种中断：是在被signal前中断还是在被signal后中断，如果是被signal前就被中断则抛出 InterruptedException，否则执行 Thread.currentThread().interrupt();
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)  //被中断则直接退出自旋
                    break;
            }
            //退出了上面自旋说明当前节点已经在同步队列上，但是当前节点不一定在同步队列队首。acquireQueued将阻塞直到当前节点成为队首，即当前线程获得了锁。然后await()方法就可以退出了，让线程继续执行await()后的代码。
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

我们先来看看fullyRelease方法的实现，其功能为释放当前线程的独占锁

	final int fullyRelease(Node node) {
        boolean failed = true;
        try {
            int savedState = getState();
            if (release(savedState)) {
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
    }

判断该节点是否在同步队列上

	final boolean isOnSyncQueue(Node node) {
        //如果当前节点状态是CONDITION或node.prev是null，则证明当前节点在等待队列上而不是同步队列上。之所以可以用node.prev来判断，是因为一个节点如果要加入同步队列，在加入前就会设置好prev字段。
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        //如果node.next不为null，则一定在同步队列上，因为node.next是在节点加入同步队列后设置的
        if (node.next != null) // If has successor, it must be on queue
            return true;
        return findNodeFromTail(node); //前面的两个判断没有返回的话，就从同步队列队尾遍历一个一个看是不是当前节点。
    }

	private boolean findNodeFromTail(Node node) {
        Node t = tail;
        for (;;) {
            if (t == node)
                return true;
            if (t == null)
                return false;
            t = t.prev;
        }
    }

我们再来看一下acquireQueued方法的实现

	final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

await方法总结

1. 构造一个新的等待队列节点加入到等待队列队尾
2. 释放锁，也就是将它的同步队列节点从同步队列队首移除
3. 自旋，直到它在等待队列上的节点移动到了同步队列（通过其他线程调用signal()）或被中断
4. 阻塞当前节点，直到它获取到了锁，也就是它在同步队列上的节点排队排到了队首

Condition.signal()

		public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException(); //如果同步状态不是被当前线程独占，直接抛出异常。从这里也能看出来，Condition只能配合独占类同步组件使用。
            Node first = firstWaiter;
            if (first != null)
                doSignal(first); //通知等待队列队首的节点。
        }

doSignal用于实现通知等待队列队首的节点

		private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&   //transferForSignal方法尝试唤醒当前节点，如果唤醒失败，则继续尝试唤醒当前节点的后继节点。
                     (first = firstWaiter) != null);
        }

signal方法总结

• 从等待队列的队首开始，尝试对队首节点执行唤醒操作；如果节点CANCELLED，就尝试唤醒下一个节点；如果再CANCELLED则继续迭代。
• 对每个节点执行唤醒操作时，首先将节点加入同步队列，此时await()操作的步骤3的解锁条件就已经开启了。然后分两种情况讨论：
  1 如果先驱节点的状态为CANCELLED(>0)或设置先驱节点的状态为SIGNAL失败，那么就立即唤醒当前节点对应的线程，此时await()方法就会完成步骤3，进入步骤4
  2 如果成功把先驱节点的状态设置为了SIGNAL，那么就不立即唤醒了。等到先驱节点成为同步队列首节点并释放了同步状态后，会自动唤醒当前节点对应线程的，这时候await()的步骤3才执行完成，而且有很大概率快速完成步骤4

Condition的本质

Condition的本质就是等待队列和同步队列的交互

转载至：Java并发编程原理与实战二十三：Condition原理分析