锁和信号量是控制并发，但是CountDownLatch(倒数计数器)是提供并发(让线程一起等待到某个条件一起触发执行)，个人感觉CountDownLatch在平常工作环境并不常用，最常见的场景就是开启多个线程同时执行某个任务，等所有任务执行完成后再做结果汇总；在countdownLatch出现之前都是使用join()方法来实现，但是join不够灵活，不能够满足不同场景下的需求·
1.1 Sync内部类源码分析
//Sync继承 AQS使用起state属性来作为count
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
//构造器
Sync(int var1) {
//设置state的值为count
this.setState(var1);
}
//获取count的值，及state的值
int getCount() {
return this.getState();
}
//重写父类tryAcquireShared的方法
protected int tryAcquireShared(int var1) {、
//如果state值为0；返回1否则返回-1
return this.getState() == 0 ? 1 : -1;
}
//重写 父类tryReleaseShared方法
protected boolean tryReleaseShared(int var1) {
for (;;) {
//获取state的值
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
//cas更新成功
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}1.2CountDownLatch 构造函数
public CountDownLatch(int count) {
//构造函数传入的值必须大于0；否则抛出异常
if (count < 0) throw new IllegalArgumentException("count < 0");
//创建一个Sync对象
this.sync = new Sync(count);
}1.3await() 方法解析
当前线程调用了await()方法后会，会将当前线程阻塞直到出现下面两种情况之一才会返回：
当所有线程调用都调用了countDown方法后，也就是说调用了await方法的都要在调用countDown方法一遍使计数器的值为0
其他线程调用了当前线程的interrupt方法中断了当前线程， 当前线程会抛出interruptedException异常返回
public void await() throws InterruptedException {
//sync调用父类的acquireSharedInterruptibly方法
sync.acquireSharedInterruptibly(1);
} public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//如果线程被中断，则抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//如果tryAcquireShared小于0，则进入AQS同步队列
if (tryAcquireShared(arg) < 0)
//调用AQS的方法进入同步队列
doAcquireSharedInterruptibly(arg);
}Sync类的tryAcquireShared方法在state等于0时返回1；否则返回-1
回到AQS的AcquireSharedInterruptibly方法，当Sync类的tryAcquireShared返回1则回到AQS的AcquireSharedInterruptibly方法返回，即await方法返回；
1.4 await(long timeout,TimeUnit unit)源码分析
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}AQS中的tryAcquireSharedNanos方法
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
return tryAcquireShared(arg) >= 0 ||
doAcquireSharedNanos(arg, nanosTimeout);
}AQS中的doAcquireSharedNanos方法
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;
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 true;
}
}
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}当线程调用了countDownLacth方法后，当前线程会被阻塞，直到下面的情况之一发生才会返回
当前线程都调用了countDownLacth对象的countDown方法，也就是计数器为0的时候，这个时候返回true
设置timeout时间到了，因为超时儿返回false
其他线程调用了当前线程的interrupt方法中断了当前线程，当前线程会抛出InterruptException异常后返回
2. countDown()方法
当前线程调用了该方法后悔递减计数器的值，递减后如果计数器为0，则会唤醒await方法而被阻塞的线程，否则什么都不做
public void countDown() {
sync.releaseShared(1);
}AQS中的releaseShared方法
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}tryReleaseShared方法需要子类实现；具体实现在CountDownLatch内部类Sync中的tryReleaseShared方法AQS中的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
}
if (h == head) // loop if head changed
break;
}
}