理解

CountDownLatch是用来协调多个线程之间的通信，它能够使一个线程需要等待另外一个线程执行完后，然后在继续执行。其中是使用了计数器来实现的，根据初始值来设置需要等待的线程数量，
当这些线程都执行完后，也就是初始值为0时，在CountDownLatch上等待的线程就能继续执行。

源码解析

我们主要来看看内部的一个结构和主要的方法await()和countDown()

首先是有个内部类Sync继承了AbstractQueuedSynchronizer

    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        
        Sync(int count) {
           //设置计数器的初始值
            setState(count);
        }

        int getCount() {
           //返回当前的计数器值
            return getState();
        }
        //判断等待的线程是否能够执行了，为0时表示可以执行
        protected int tryAcquireShared(int acquires) {
           //当前计数器为0时表示等待的线程可以执行了
            return (getState() == 0) ? 1 : -1;
        }
       //当其他线程执行完后计数器减1
        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
               // 如果当前计数器已经为0了，说明有其他线程已经执行完毕，等待的线程已经
              //在执行了，直接返回false
                if (c == 0)
                    return false;
                int nextc = c-1;
                //尝试更新计算器的值
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

在来看看构造方法，内部只有一个构造方法 ,就是设置计算数的初始值

    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

然后是await方法 进行了重载

    //调用这个方法时就会被挂起，直到计数器为0时就继续执行
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    //这个和上面的区别就是设置了时间，等待一段时间后计数器还没为0时就继续执行
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

最后是countDown方法

    //每调用一次计数器的值减1，直到0
    public void countDown() {
        sync.releaseShared(1);
    }

下面我们来看看使用例子

public class CountDown {
    public static void main(String[] args) {
        CountDownLatch downLatch=new CountDownLatch(2);
        try {
            new Thread(){
                public void run(){
                    System.out.println(Thread.currentThread().getName()+"开始执行："+LocalTime.now());
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"执行完毕："+LocalTime.now());
                    downLatch.countDown();
                }
            }.start();
            new Thread(){
                public void run(){
                    System.out.println(Thread.currentThread().getName()+"开始执行："+LocalTime.now());
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"执行完毕："+LocalTime.now());
                    downLatch.countDown();
                }
            }.start();
            downLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行完毕。");
    }
}
//执行结果
Thread-1开始执行：16:40:47.426
Thread-0开始执行：16:40:47.426
Thread-1执行完毕：16:40:49.426
Thread-0执行完毕：16:40:49.426
main执行完毕。

总结

CountDownLatch是用于某个线程等待若干个线程执行完毕后，它才执行的。缺点就是CountDownLatch是不能够重用的，只能用一次，如果需要重用，可以考虑用CyclicBarrier。