countdownlatch 是一个同步工具类，它允许一个或多个线 程一直等待，直到其他线程的操作执行完毕再执行。从命 名可以解读到 countdown 是倒数的意思，类似于我们倒计时的概念。
countdownlatch 提供了两个方法，一个是 countDown， 一个是 await， countdownlatch 初始化的时候需要传入一 个整数，在这个整数倒数到 0 之前，调用了 await 方法的程序都必须要等待，然后通过 countDown 来倒数。
案例
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch=new CountDownLatch(3);
System.out.println("main start");
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"->begin");
countDownLatch.countDown(); //初始值-1 =3-1=2;
System.out.println(Thread.currentThread().getName()+"->end");
},"t1").start();
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"->begin");
countDownLatch.countDown(); //2-1=1;
System.out.println(Thread.currentThread().getName()+"->end");
},"t2").start();
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"->begin");
countDownLatch.countDown(); //1-1=1;
System.out.println(Thread.currentThread().getName()+"->end");
},"t3").start();
countDownLatch.await(); //阻塞Main线程
System.out.println("main end");
}
}
从代码的实现来看，有点类似 join 的功能，但是比 join 更 加灵活。CountDownLatch 构造函数会接收一个 int 类型 的参数作为计数器的初始值，当调用 CountDownLatch 的 countDown 方法时，这个计数器就会减一。
通过 await 方法去阻塞去阻塞主流程.
源码分析
对于 CountDownLatch，我们仅仅需要关心两个方法，一 个是 countDown() 方法，另一个是 await() 方法。 countDown() 方法每次调用都会将 state 减 1，直到 state 的值为 0;而 await 是一个阻塞方法，当 state 减 为 0 的时候，await 方法才会返回。await 可以被多个线 程调用，大家在这个时候脑子里要有个图:所有调用了 await 方法的线程阻塞在 AQS 的阻塞队列中，等待条件 满足(state == 0)，将线程从队列中一个个唤醒过来。
初始化state
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// 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;
}
}
}
protected final void setState(int newState) {
state = newState;
}
await
tryAcquireShared尝试获取共享锁，如果state为0，不阻塞当前线程，否则阻塞，从方法名可以看出，此处判断是否获取共享锁。
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
doAcquireSharedInterruptibly和互斥锁的代码基本相同
不同点：
- addWaiter 设置为 shared 模式。
- tryAcquire 和 tryAcquireShared 的返回值不同，因此会
多出一个判断过程 - 在 判 断 前 驱 节 点 是 头 节 点 后 ， 调 用 了
setHeadAndPropagate 方法，而不是简单的更新一下头节点。
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//添加共享锁node
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) {
//更新头节点并释放其他共享node
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
countDown
由于线程被 await 方法阻塞了，所以只有等到 countdown 方法使得 state=0 的时候才会被唤醒，我们 来看看 countdown 做了什么？
- 只有当 state 减为 0 的时候，tryReleaseShared 才返
回 true, 否则只是简单的 state = state - 1 - 如果 state=0, 则调用 doReleaseShared
唤醒处于 await 状态下的线程
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
//尝试释放共享锁
if (tryReleaseShared(arg)) {
//释放共享锁
doReleaseShared();
return true;
}
return false;
}
用自旋的方法实现 state 减 1
protected boolean tryReleaseShared(int releases) {
// 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;
}
}
如果状态为0，判断头结点是不是 SIGNAL 状态，如果是，则修改为 0，并且唤醒头结点的下一个节点
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);
}
//PROPAGATE: 标识为 PROPAGATE 状态的节点，是共享锁模式下的节点状态，处于这个状态 下的节点，会对线程的唤醒进行传播
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
// 如果到这里的时候，前面唤醒的线 程已经占领了 head，那么再循环
// 通过检查头节点是否改变了，如果改变了就继续循环
if (h == head) // loop if head changed
break;
}
}
h == head:说明头节点还没有被刚刚用 unparkSuccessor 唤醒的线程(这里可以理解为 ThreadB)占有，此时 break 退出循环。
h != head:头节点被刚刚唤醒的线程(这里可以理解为 ThreadB)占有，那么这里重新进入下一轮循环，唤醒下 一个节点(这里是 ThreadB )。
doAcquireSharedInterruptibly
一旦 第一个等待线程 被唤醒，代码又会继续回到 doAcquireSharedInterruptibly 中来执行。如果当前 state 满足=0 的条件，则会执行 setHeadAndPropagate 方法。
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
这个方法的主要作用是把被唤醒的节点，设置成 head 节 点。 然后继续唤醒队列中的其他线程。
代码分析完毕，可以看出ReentrantLock学习后，再学习其他的并发工具的效果是事半功倍的。