JUC源码阅读(三)-CountDownLatch

一、CountDownLatch简介

  CountDownLatch是一个基于AQS实现的同步辅助类，它允许一个或多个主任务线程一直等待，直到一组子任务线程完成。内部采用的公平锁和共享锁的机制实现。
  由AQS的数据模型可推测，CountDownLatch应该是将一个或多个主任务线程放入到CLH等待队列中，等待所有子线程执行完后再获取锁执行下一步操作，而每个子任务执行完都会将计数-1，CLH等待队列中主任务需要不停的检测计数是否归零。

二、CountDownLatch的核心方法

1、CountDownLatch#await()

该方法是使主线程进入CLH等待队列中，进入阻塞状态。

public void await() throws InterruptedException {
	// 委托sync调用AQS的方法  
	sync.acquireSharedInterruptibly(1);
}

AbstractQueuedSynchronizer#acquireSharedInterruptibly

public final void acquireSharedInterruptibly(int arg)
		throws InterruptedException {
	// 如果当前线程在进入这个方法时设置了中断状态；或者当前线程在等待时被设置了中断状态
	// 那么将抛出中断异常，并且当前的线程的中断状态会被清除。
	if (Thread.interrupted())
		throw new InterruptedException();
	// CountDownLatch的内部类Sync重写了tryAcquireShared，此方法判断同步状态值是否为0？
	// 如果为0返回1，方法直接返回，主任务得以继续执行；
	// 如果不为0返回-1，则用 Node 封装一下当前线程，追加到同步队列的尾部，等待在合适的时机去获得锁
	if (tryAcquireShared(arg) < 0)
		doAcquireSharedInterruptibly(arg);
}

CountDownLatch.Sync#tryAcquireShared

protected int tryAcquireShared(int acquires) {
	return (getState() == 0) ? 1 : -1;
}

AbstractQueuedSynchronizer#doAcquireSharedInterruptibly

private void doAcquireSharedInterruptibly(int arg)
	throws InterruptedException {
	// 创建共享模式的节点
	final Node node = addWaiter(Node.SHARED);
	boolean failed = true;
	try {
		for (;;) {
			final Node p = node.predecessor();
			if (p == head) {
				int r = tryAcquireShared(arg);
				if (r >= 0) {
					setHeadAndPropagate(node, r);
					p.next = null; // help GC
					failed = false;
					return;
				}
			}
			if (shouldParkAfterFailedAcquire(p, node) &&
				parkAndCheckInterrupt())
				// 检测到中断则直接抛中断异常
				throw new InterruptedException();
		}
	} finally {
		if (failed)
			cancelAcquire(node);
	}
}

AbstractQueuedSynchronizer#doAcquireSharedInterruptibly的代码逻辑和之前一篇AQS源码中的AbstractQueuedSynchronizer#acquireQueued几乎一样，只不过此方法是共享模式的节点，且检测到中断直接抛异常。

2、CountDownLatch#countDown

public void countDown() {
	// 委托sync调用AQS的方法
	sync.releaseShared(1);
}

AbstractQueuedSynchronizer#releaseShared

public final boolean releaseShared(int arg) {
	// 尝试释放同步资源，对 state 进行递减，直到 state 变成 0；当 state 递减为 0 时，才返回 true。
	if (tryReleaseShared(arg)) {
		// 唤醒CLH队列中的所有主任务线程
		doReleaseShared();
		return true;
	}
	return false;
}

CountDownLatch.Sync#tryReleaseShared

protected boolean tryReleaseShared(int releases) {
	// 对 state 进行递减，直到 state 变成 0；当 state 递减为 0 时，才返回 true。
	for (;;) {
		int c = getState();
		if (c == 0)
			return false;
		int nextc = c-1;
		if (compareAndSetState(c, nextc))
			return nextc == 0;
	}
}

AbstractQueuedSynchronizer#doReleaseShared

private void doReleaseShared() {
	for (;;) {
		Node h = head;
		if (h != null && h != tail) {
			int ws = h.waitStatus;
			if (ws == Node.SIGNAL) {
				if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
					continue;            // loop to recheck cases
			    // 唤醒头结点
				unparkSuccessor(h);
			}
			else if (ws == 0 &&
					 !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
				continue;                // loop on failed CAS
		}
		// 这里是否有疑问明明都有这个 Node h = head为啥还要在判断一次？是因为这个阻塞节点唤醒后，接着要唤醒下一个节点
		if (h == head)                   // loop if head changed
			break;
	}
}

CLH队列中的头结点唤醒之后，从被阻塞的地方继续执行代码，就是就行执行下图红框所在的死循环，进入下一个循环判断，由于state的状态值为0,tryAcquireShared返回值为1 ，大于0会进入绿框中的代码，重新设置头结点。

AbstractQueuedSynchronizer#setHeadAndPropagate

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node); //这里重新设置头节点 （已上面  第一次释放锁 h== head 的重复判断相对应）
    if (propagate > 0 || h == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared(); //注意这里 会进入这里 
    }
}

doReleaseShared就是释放第一个头结点所调用的，在这里，被唤醒的线程再调用一次，再唤醒后续线程。

总结一下这个唤醒机制就是：先唤醒一个线程（第一个阻塞的线程）
然后被唤醒的线程又会执行到这里唤醒后续线程，
如此重复下去，最终所有线程都会被唤醒，其实这也是AQS共享锁的唤醒原理。