来看下CountDownLatch�，主要用于线程间通信，await就是阻塞，等待别人执行countDown把定义的数字减完，就可以继续执行了，那么去看下内部怎么实现的

CountDownLatch countDownLatch = new CountDownLatch(1);
countDownLatch.await();
countDownLatch.countDown();

�

内部Sync 继承了AQS

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) {// 直接给state赋值setState(count);}int getCount() {// 现在的数量return getState();}protected int tryAcquireShared(int acquires) {// 如果等于0 返回1，否则返回-1return (getState() == 0) ? 1 : -1;}protected boolean tryReleaseShared(int releases) {// Decrement count; signal when transition to zerofor (;;) {// 拥有的数int c = getState();// 为0的时候直接返回false，不需要释放了，已经都释放完了if (c == 0)return false;// 减去1int nextc = c - 1;// cas设置，成功的话，就判断是不是为0，为0的时候可以后面解开阻塞if (compareAndSetState(c, nextc))return nextc == 0;}}
}

可以看到内部使用Sync继承了AQS，然后设置的数量直接被Sync设置到了state，释放的时候也不需要管传入值，只能减1，为0的时候直接返回，获取资源的时候就不对state做改变，直接判断是不是为0，为0的时候返回1，否则返回-1

await 方法

public void await() throws InterruptedException {sync.acquireSharedInterruptibly(1);
}
//AQS的方法
public final void acquireSharedInterruptibly(int arg)throws InterruptedException {
if (Thread.interrupted())throw new InterruptedException();
// 这里小于0就是没获取到对应资源，进入队列等待
if (tryAcquireShared(arg) < 0)doAcquireSharedInterruptibly(arg);
}
// 查看进入队列操作
private void doAcquireSharedInterruptibly(int arg)throws InterruptedException {// 增加共享节点，这里的SHard会被存在nextWaiter
final Node node = addWaiter(Node.SHARED);try {for (;;) {// 前节点final Node p = node.predecessor();if (p == head) {// 这里在获取，这里交给子类实现的，上面Sync实现的就是判断// state是不是为0，为0返回1，否则返回-1int r = tryAcquireShared(arg);if (r >= 0) {// 大于0 证明state为0了，等于0证明自己获取到了，后续//，这里放行了，通知后面的setHeadAndPropagate(node, r);p.next = null; // help GCreturn;}}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())throw new InterruptedException();}} catch (Throwable t) {cancelAcquire(node);throw t;}
}private void setHeadAndPropagate(Node node, int propagate) {Node h = head; // Record old head for check below// 设置其为头节点setHead(node);//这里传入的1 是大于0的就是还可以继续获取，等于0的证明上个获取完了// 就需要判断，如果头节点为空的，或者头节点的状态if (propagate > 0 || h == null || h.waitStatus < 0 ||(h = head) == null || h.waitStatus < 0) {// 遍历到下一个Node s = node.next;// 判断是不是共享的，这里是的CountDownLatch就是用的共享锁if (s == null || s.isShared())// 释放doReleaseShared();}
}// 共享的释放资源
private void doReleaseShared() {for (;;) {Node h = head;// 有值if (h != null && h != tail) {int ws = h.waitStatus;if (ws == Node.SIGNAL) {// signal状态，设置为0，成功了，就直接下一步，不成功一直循环if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))continue;            // loop to recheck cases// unparkunparkSuccessor(h);}// 下次就为0了，然后设置为传播else if (ws == 0 &&!h.compareAndSetWaitStatus(0, Node.PROPAGATE))continue;                // loop on failed CAS}if (h == head)                   // loop if head changedbreak;}
}
// 执行了唤醒操作
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)node.compareAndSetWaitStatus(ws, 0);// 这里唤醒之后Node s = node.next;if (s == null || s.waitStatus > 0) {s = null;for (Node p = tail; p != node && p != null; p = p.prev)if (p.waitStatus <= 0)s = p;}// 唤醒对应的线程，让线程再次获取资源if (s != null)LockSupport.unpark(s.thread);
}

countDown 方法

public void countDown() {sync.releaseShared(1);
}
// AQS的释放共享锁的过程
public final boolean releaseShared(int arg) {// 这里的try是COuntDOwnLatch实现的，是把对应的state判断下，如果为0直接返回false// 那就走下面直接返回false了，如果减去1之后判断是不是0，相等true，不等还是false// 也就是把state正好减到0，走下面doReleaseSharedif (tryReleaseShared(arg)) {doReleaseShared();return true;}return false;
}
protected boolean tryReleaseShared(int releases) {// Decrement count; signal when transition to zerofor (;;) {int c = getState();if (c == 0)return false;int nextc = c - 1;if (compareAndSetState(c, nextc))return nextc == 0;}
}private void doReleaseShared() {for (;;) {Node h = head;if (h != null && h != tail) {int ws = h.waitStatus;// 如果为Signalif (ws == Node.SIGNAL) {// 设置为0if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))continue;            // loop to recheck casesunparkSuccessor(h);}else if (ws == 0 &&!h.compareAndSetWaitStatus(0, Node.PROPAGATE))continue;                // loop on failed CAS}if (h == head)                   // loop if head changedbreak;}
}
// 释放对应的线程
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)node.compareAndSetWaitStatus(ws, 0);Node s = node.next;if (s == null || s.waitStatus > 0) {s = null;for (Node p = tail; p != node && p != null; p = p.prev)if (p.waitStatus <= 0)s = p;}if (s != null)LockSupport.unpark(s.thread);
}

总结

countDownLatch是在利用AQS的共享锁来实现的，主要就是设置一个初始的值，然后await是在判断state是不是为0，为0的时候就返回1，也就是继续向后传播，会唤醒后续所有的等待节点，countDown是在对设置的state减1，这里countDownLatch自己实现的tryRelease方法，就是对其减1，然后判断结果是不是为0，为0的时候返回true对排队的进行唤醒