countdownlatch
这是一个非常有意思的类，看下面的代码：
countdownlatch countDownLatch = new CountDownLatch(1);
new Thread(new Runnable() {
@Override
public void run() {
try {
long startTime = system.currenttimemillis();
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println("awaitTime : " + (endTime - startTime) / 1000 + "seconds");
} catch (InterruptedException e) {}
}
}).start();
Thread.sleep(5000);
countDownLatch.countDown();
我们创建的线程会在await那个地方等着，直到在其他地方调用了countDown这个方法，阻塞的方法才会继续执行，下面是我们代码执行的结果：
接下来我们就来看一下这个有趣的类是如何实现的：
public CountDownLatch(int count) {
if (count < 0) throw new illegalargumentException("count < 0");
this.sync = new Sync(count);
}
我们发现这个类同样也是由AQS实现的：
Sync(int count) {
setState(count);
}
将资源的数目设置为我们传进去的参数
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
await方法其实就是获取资源，在这个方法里面调用了在共享模式下可中断的获取资源：
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
首先尝试获取资源，如果返回值小于0就放到同步队列里面
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
如果剩余的资源的数目是0，说明不能获取资源了，要返回1，否则返回-1，既然是这样，那岂不是只有有资源的时候才有权利进入同步队列，这样想的话其实就和await的意思对应起来了，我们继续向下看来验证我们的猜想，由于资源的数目是1，所以肯定有剩余的资源：
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);
}
}
果真就和我们上一篇文章分析信号量一样的方法，这个类在获取资源的时候也是在共享模式下进行的，只不过信号量是在获取不到资源的时候才进入同步队列，而CountDownLatch是在有剩余资源的时候线程才进入同步队列，我们现在就清楚了，原来在有资源的情况下，线程调用await会直接进入同步队列，只有我们调用countdown的时候，它们才开始按同步队列的顺序来获取资源，接下来我们就看一下这个方法验证我们的猜想：
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
首先会尝试释放指定数目的资源，然后唤醒同步队列里面的结点：
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;
}
}
对同步对列中的资源数目-1
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
}
if (h == head) // loop if head changed
break;
}
}
这个方法和信号量的方法是一样的我们就不在解释了，这个时候唤醒的线程在尝试获取资源的时候由于state是0，所以返回-1，成功从同步队列中移除。
到这里我们应该就清楚了，CountDownLatch的思路是这样的：
首先我们在创建这个类的时候会传入资源的个数，当我们调用await的时候，线程会因为还有剩余的资源而进入同步队列当中，只用当我们调用countdown方法的时候，会消耗资源，当资源消耗完毕的时候，所有线程才会有条不紊的从同步队列中出来继续工作。
那我们就可以举个例子了：CountDownLatch相当于一个公司，它手里有资金、这个公司还有前途的时候那些员工才会老老实实的跟着他，收起自己的小脾气，收起自己的理想，一旦这个公司将他的资金消耗光的时候，那些员工认为跟着呆在这个公司也没意思了，他都没钱了，更别说前途了，所以就会放弃他去干自己的事，去实现自己的理想。
文章最后发布于: 2018-10-12 22:47:46
相关阅读
java-多线程-CountDownLatch(闭锁) CyclicBarrier(栅
（代码来源网络共享） 这几个工具类其实说白了就是为了能够更好控制线程之间的通讯问题~ CountDownLatch 是一个同步的辅助类，允许
专题相关文章：从内存可见性看Volatile、原子变量和CAS算法多线程并发之CountDownLatch(闭锁)使用详解多线程并发之显示锁Lock与其
线上生产环境dubbo报线程池满了，经过一天排查锁定在开三个线程计算最后合并数据的步骤中。简单描述下该步骤线程开三个 调用三个不
一、用法 先看CountDownLatch的用处和用法 每个线程如果持有同一个CountDownLatch，当他们都调用countdownLatch的await(）方法的时候