上一篇文章从源码层面说了一下CountDownLatch 中 await() 的原理。这篇文章说一下countDown() 。
public void countDown() { //CountDownLatch
sync.releaseShared(1);
}
↓
public final boolean releaseShared(int arg) { //AQS
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
↓
protected boolean tryReleaseShared(int releases) { //CountDownLatch.Sync
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
通过构造器 CountDownLatch end = new CountDownLatch(2); state 被设置为2，所以c == 2，nextc = 2-1,
然后通过下面这个CAS操作将state设置为1。
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
此时nextc还不为0，返回false。一直等到countDown() 方法被调用两次，state == 0，nextc ==0,此时返回true。
进入doReleaseShared()方法。
doReleaseShared();
↓
private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
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
}
if (h == head) // loop if head changed
break;
}
}
回顾一下此时的等待队列模型。
+--------------------------+ prev +------------------+
head | waitStatus = Node.SIGNAL | <---- node(tail) | currentThread |
+--------------------------+ +------------------+
此时head 不为null，也不为tail，waitStatus == Node.SIGNAL，所以进入 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) 这个判断。
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
↓
/**
* CAS waitStatus field of a node.
*/
private static final boolean compareAndSetWaitStatus(Node node,
int expect,
int update) {
return unsafe.compareAndSwapInt(node, waitStatusOffset,
expect, update);
}
这个CAS 操作将 state 设置为 0 ，也就是说此时Head 中的 waitStatus 是0.此时队列模型如下所示
+----------------+ prev +------------------+
head | waitStatus = 0 | <---- node(tail) | currentThread |
+----------------+ +------------------+
该方法返回true。进入unparkSuccessor(h);
unparkSuccessor(h);
↓
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0); /*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
s 就是head的后继结点，也就是装有当前线程的结点。s != null ，并且s.waitStatus ==0 ，所以进入 LockSupport.unpark(s.thread);
public static void unpark(Thread thread) {
if (thread != null)
UNSAFE.unpark(thread);
}
也就是unlock 被阻塞的线程。裁判被允许吹哨了！
countDown() 的原理就此就非常清晰了，
每执行一次countDown() 方法，state 就是减1，直到state == 0，则开始释放被阻塞在队列中的线程，根据前驱结点中waitStatus的状态，释放后续结点中的线程。
OK,回到上一篇文章的问题，什么时候跳出下面这个循环（await方法中的循环）
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();
}
此时state == 0，所以进入 setHeadAndPropagate 方法。
setHeadAndPropagate(node, r);
↓
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);
/*
* Try to signal next queued node if:
* Propagation was indicated by caller,
* or was recorded (as h.waitStatus either before
* or after setHead) by a previous operation
* (note: this uses sign-check of waitStatus because
* PROPAGATE status may transition to SIGNAL.)
* and
* The next node is waiting in shared mode,
* or we don't know, because it appears null
*
* The conservatism in both of these checks may cause
* unnecessary wake-ups, but only when there are multiple
* racing acquires/releases, so most need signals now or soon
* anyway.
*/
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
↓
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}
这个方法将head 的后继结点变为head。该方法过后，又将node的next结点设置为null，模型变成下图
prev +---------+ next
null <---- node(tail/head) | null | ----> null
+---------+
也就是node head tail 什么的都被置为null，等待GC回收了，这个时候return，跳出了for循环，队列被清空。
下面演示一下整个过程
setHeadAndPropagate(node, r);
+----------------+
head(tail) | waitStatus=0 |
| thread =null |
+----------------+
↓
+----------------+ +----------------+
| waitStatus=0 | prev | waitStatus=0 |
head(tail) | thread =null | <---- node | currentThread |
+----------------+ +----------------+
↓
+----------------+ +----------------+
| waitStatus=0 | prev | waitStatus=0 |
head | thread =null | <---- node(tail) | currentThread |
+----------------+ +----------------+
↓
+----------------+ +----------------+
| Node.SIGNAL | prev | waitStatus=0 |
head | thread =null | <---- node(tail) | currentThread |
+----------------+ +----------------+
↓
+----------------+ +----------------+
| waitStatus=0 | prev | waitStatus=0 |
head | thread =null | <---- node(tail) | currentThread |
+----------------+ +----------------+
↓
+----------------+
prev | waitStatus=0 | next
null <---- node(tail/head) | null | ----> null
+----------------+
CountDownLatch 的核心就是一个阻塞线程队列，这是由链表构造而成的队列，里面包含thread 和 waitStatus，其中waitStatus说明了后继结点线程状态。
state 是一个非常重要的标志，构造时，设置为对应的n值，如果n != 0，阻塞队列将一直阻塞，除非中断线程。
每次调用countDown() 方法，就是将state-1，而调用await() 方法就是将调用该方法的线程加入到阻塞队列，直到state==0，才能释放线程。