JUC之CountDownLatch

CountDownLatch是一个同步辅助类，通过AQS实现的一个闭锁。在其他线程完成它们的操作之前，允许一个多个线程等待。简单来说，CountDownLatch中有一个锁计数，在计数到达0之前，线程会一直等待。

从锁类别来说，CountDownLatch是一个“共享锁”，内部定义了自己的同步器Sync，Sync继承自AQS，实现了tryAcquireShared和tryReleaseShared两个方法。需要注意的是，CountDownLatch中的锁是响应中断的，如果线程在对锁进行操作期间发生中断，会直接抛出InterruptedException。

构造函数

public CountDownLatch(int count) 
{
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}
//CountDownLatch中的计数其实就是AQS的state
Sync(int count) 
{
        setState(count);
}

await（）

    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    //AQS中对acquireSharedInterruptibly函数的实现
    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;
    }

Note：await()的实现非常简单，就是通过对资源state剩余量（state==0 ? 1 : -1）来判断是否获取到锁。在《AQS》篇中我们讲到过，tryAcquireShared函数规定了它的返回值类型：成功获取并且还有可用资源返回正数；成功获取但是没有可用资源时返回0；获取资源失败返回一个负数。 也就是说，只要state!=0，线程就进入等待队列阻塞。

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;
            }
 }

Note：如果释放资源后state==0,说明已经到达latch，此时就可以调用doReleaseShared唤醒等待的线程。