集合与多线程系列-AbstractQueuedSynchronizer（三）

1 Condition接口

// 当前线程在接到信号或被中断之前一直处于等待状态。
void await() throws InterruptedException;
// 当前线程在接到信号之前一直处于等待状态
void awaitUninterruptibly();
// 当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间，如果在nanosTimesout之前唤醒，那么返回值 = nanosTimeout - 消耗时间，如果返回值 <= 0 ,则可以认定它已经超时了。
long awaitNanos(long nanosTimeout) throws InterruptedException;
// 当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
boolean await(long time, TimeUnit unit) throws InterruptedException;
// 当前线程在接到信号、被中断或到达指定最后期限之
boolean awaitUntil(Date deadline) throws InterruptedException;
// 唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。
void signal();
// 唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。
void signalAll();

2 AQS中的条件队列

3 JDK源码

AQS源码中ConditionObject实现了Condition接口。

3.1 ConditionObject#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)) {
            	// 如果不在同步队列中，park当前线程，直到前驱节点释放唤醒当前节点
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                	// 醒来后判断线程是否被中断，如果被中断，跳出while循环
                    break;
            }
            // 独占式获取锁
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

	// 创建条件队列节点，并添加到队尾，注意当前线程已经持有锁，无需CAS
	private Node addConditionWaiter() {
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }

		// 删除条件队列中状态为取消的节点（释放锁过程中如果失败会将节点状态置为取消）
		private void unlinkCancelledWaiters() {
            Node t = firstWaiter;
            Node trail = null;
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {
                    t.nextWaiter = null;
                    if (trail == null)
                        firstWaiter = next;
                    else
                        trail.nextWaiter = next;
                    if (next == null)
                        lastWaiter = trail;
                }
                else
                    trail = t;
                t = next;
            }
        }

	// 完全释放锁（存在可重入锁的情况）
	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;
        }
    }

	public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

	// 判断节点是否在同步队列中
	final boolean isOnSyncQueue(Node node) {
        if (node.waitStatus == Node.CONDITION || node.prev == null)
        	// 如果节点状态为CONDITION或者前继节点为空，则一定不在同步队列中
            return false;
        if (node.next != null)
        	// 如果节点后继节点不为空，则一定在同步队列中
            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;
        }
    }

	// 判断线程是否被中断
	// 中断请求在signal操作之前：THROW_IE
    // 中断请求在signal操作之后：REINTERRUPT
    // 期间没有收到任何中断请求：0
	private int checkInterruptWhileWaiting(Node node) {
            return Thread.interrupted() ?
                (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
                0;
        }

	// 取消等待后将节点从条件队列转到同步队列
	final boolean transferAfterCancelledWait(Node node) {
		// 判断中断请求在signal之前还是之后，做不同操作
        if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
        	// 中断请求在signal操作之前，将节点加入同步队列队尾
            enq(node);
            return true;
        }
        // 中断请求在signal操作之后，说明signal通知已经将节点从条件队列转到同步队列
        while (!isOnSyncQueue(node))
        	// 如果还不在同步队列，说明正在转移，自旋等待
            Thread.yield();
        return false;
    }

	private void reportInterruptAfterWait(int interruptMode)
            throws InterruptedException {
            if (interruptMode == THROW_IE)
                throw new InterruptedException();
            else if (interruptMode == REINTERRUPT)
                selfInterrupt();
        }

3.2 ConditionObject#awaitNanos

	public final long awaitNanos(long nanosTimeout)
                throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            // 计算超时时间
            final long deadline = System.nanoTime() + nanosTimeout;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (nanosTimeout <= 0L) {
                	// 如果已超时，取消等待
                    transferAfterCancelledWait(node);
                    break;
                }
                if (nanosTimeout >= spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
                // 计算剩余时间
                nanosTimeout = deadline - System.nanoTime();
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return deadline - System.nanoTime();
        }

3.3 ConditionObject#awaitUntil

	public final boolean awaitUntil(Date deadline)
                throws InterruptedException {
            long abstime = deadline.getTime();
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            boolean timedout = false;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (System.currentTimeMillis() > abstime) {
                    timedout = transferAfterCancelledWait(node);
                    break;
                }
                LockSupport.parkUntil(this, abstime);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return !timedout;
        }

3.4 ConditionObject#await

	public final boolean await(long time, TimeUnit unit)
                throws InterruptedException {
            long nanosTimeout = unit.toNanos(time);
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            final long deadline = System.nanoTime() + nanosTimeout;
            boolean timedout = false;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (nanosTimeout <= 0L) {
                    timedout = transferAfterCancelledWait(node);
                    break;
                }
                if (nanosTimeout >= spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
                nanosTimeout = deadline - System.nanoTime();
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return !timedout;
        }

3.5 ConditionObject#signal

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

	private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }
        
    // signal通知后将节点从条件队列转到同步队列
    final boolean transferForSignal(Node node) {
        // CAS将节点状态置为0
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        	// CAS操作失败，说明节点状态已经变为取消状态（完全释放锁操作失败会将状态置为取消）
            return false;
		// 转移到同步队列队尾，返回前驱别点
        Node p = enq(node);
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        	// 如果前驱节点状态为取消或者CAS操作将前驱节点状态改为SIGNAL失败，需要立即唤醒当前线程
            LockSupport.unpark(node.thread);
        return true;
    }

3.6 ConditionObject#doSignalAll

	public final void signalAll() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
            	// 通知所有节点
                doSignalAll(first);
        }

	private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                transferForSignal(first);
                first = next;
            } while (first != null);
        }