Java并发编程之CountDownLatch闭锁

public class CountDownLatchTest {
    /**
     * 计数器，初始为0
     */
    private Integer count = 0;
    public Integer getCount(){
        return count;
    }
    /**
     * 执行+1操作
     */
    public void add(){
        count++;
    }
    public static void main(String[] args){
        CountDownLatchTest test = new CountDownLatchTest();
        // 线程个数
        int threadCount = 3;
        //初始化工作线程的个数，并用CountDownLatch管理
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for(int i=0;i<threadCount;i++) {
            new Thread(() -> {
                test.add();
                countDownLatch.countDown();
            }).start();
        }
        try {
            //等待所有线程执行完毕，在所有线程都执行完毕之前主线程会阻塞
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(test.getCount());
    }
}

public class CountDownLatch {
 //继承于AQS的同步器
 private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        //有参构造函数，count记录了共享资源的个数
        Sync(int count) {
            setState(count);
        }
        //获取当前共享资源的个数
        int getCount() {
            return getState();
        }
        /**
        * 尝试以共享方式获取资源
        * @return 1表示获取成功，-1表示获取失败
        */
        protected int tryAcquireShared(int acquires) {
            //如果当前资源个数为0，则表示获取成功，否则表示失败
            return (getState() == 0) ? 1 : -1;
        }
       /**
        * 尝试以共享方式释放资源
        * @return true表示释放成功，false表示释放失败
        */
        protected boolean tryReleaseShared(int releases) {
            // 对当前资源执行-1操作
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                //CAS更新资源个数，CAS失败表示有其他线程竞争，此时需要重试
                if (compareAndSetState(c, nextc))
                    //执行-1操作后，如果资源个数为0，则表示释放成功
                    return nextc == 0;
            }
        }
    }
    private final Sync sync;
    //有参构造函数，可以看到CountDownLatch中禁用了默认构造函数，意味着必须传入资源个数
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }
    //等待操作，此方法会使调用线程阻塞，直到其他调用countdown的方法都执行完毕
    public void await() throws InterruptedException {
        //此处调用的是AQS的acquireSharedInterruptibly方法，下文会具体分析
        sync.acquireSharedInterruptibly(1);
    }
    //和await()类似，但是有一个等待的超时时间，过了超时时间会自动取消等待
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }
    //将state的值-1，当getState()==0时，会唤醒调用await()线程
    public void countDown() {
        //调用AQS的releaseShared方法，下文会具体分析
        sync.releaseShared(1);
    }
    //获取当前资源的个数
    public long getCount() {
        return sync.getCount();
    }
}

public final void acquireSharedInterruptibly(int arg)
    throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //尝试获取资源失败（tryAcquireShared的返回值<0），会将当前线程阻塞并排队等待
    if (tryAcquireShared(arg) < 0)
        //该方法会将当前线程阻塞，并放入AQS的同步队列等待，此处不再分析
        doAcquireSharedInterruptibly(arg);
}
//释放共享资源
public final boolean releaseShared(int arg) {
    //尝试释放共享资源成功时（此处要结合CountDownLatch提供的tryReleaseShared方法理解），进行具体的释放操作
    if (tryReleaseShared(arg)) {
        //AQS提供的执行具体的资源释放操作，会唤醒调用await()方法的线程
        doReleaseShared();
        return true;
    }
    return false;
}