CountDownLatch 这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。

简单示例

陪女朋友看病

如果你女朋友去看病，医院里边排队的人很多，如果你女朋友一个人去的话，要先看大夫，看完大夫再去排队交钱取药。当你陪你女朋友一起去，你女朋友可以去看病，而你可以去排队交钱取药。当两件事同时完成后，你才能和你女朋友一起回家。

女朋友去看病

public class SeeDoctorTask implements Runnable {
    private CountDownLatch countDownLatch;
    public SeeDoctorTask(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    public void run() {
        try {
            System.out.println("开始看医生");
            Thread.sleep(2000);
            System.out.println("看医生结束，准备离开病房");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if (countDownLatch != null)
                //看病完成，计数器减1
                countDownLatch.countDown();
        }
    }
}

你排队去拿药

public class QueueTask implements Runnable {
    private CountDownLatch countDownLatch;
    public QueueTask(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    public void run() {
        try {
            System.out.println("开始在医院药房排队买药....");
            Thread.sleep(5000);
            System.out.println("排队成功，可以开始缴费买药");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if (countDownLatch != null)
                //拿药完成后，计数器减1
                countDownLatch.countDown();
        }
    }
}

当你女朋友看完病并且你拿完药后，你们可以一起回家

public class CountDownLaunchRunner {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(new SeeDoctorTask(countDownLatch)).start();
        new Thread(new QueueTask(countDownLatch)).start();
        //只有女朋友看完病和你拿完药后，你们才可以一起回家
        countDownLatch.await();
        System.out.println("over，回家 cost:"+(System.currentTimeMillis()-now));
    }
}

模拟高并发

CountDownLantch 反着来用还可以模拟高并发场景

public class CountDownLaunchRunner {
    static int sub = 0;
    static Object object = new Object();
    public static void main(String[] args) throws InterruptedException {
        long now = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //开启10个线程
        for(int i=0;i<10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //每个线程都阻塞，等待主线程进行countDown()操作，10个线程可以并发执行
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (object){
                        for(int j=0;j<1000;j++){
                            sub++;
                        }
                    }
                }
            });
        }
        Thread.sleep(3000);
        //执行countDown()，上面阻塞的所有线程都可以开始执行
        countDownLatch.countDown();
        System.out.println("over，回家 cost:"+(System.currentTimeMillis()-now));
    }
}

实现原理

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}
----------------------------
Sync(int count) {
    //设置AQS中state的值为我们指定的参数
    setState(count);
}

await()——-阻塞等待

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
-------------------------
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

调用tryAcquireShared()，如果当前计数器（state）不为0，说明还有线程未执行完

protected int tryAcquireShared(int acquires) {
    //如果当前state=0，说明其他线程的任务已完成，返回1
    //如果当前state>0，说明还有线程任务未完成，返回-1
    return (getState() == 0) ? 1 : -1;
}

与其他AQS工具的做法一样，创建节点加入CLH队列，并且将线程阻塞

private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                //如果state=0，返回1
                int r = tryAcquireShared(arg);
                //r=1，说明其他所有线程任务执行完
                if (r >= 0) {
                    //以广播的方式唤醒所有调用await()方法阻塞的线程
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

当state=0，说明其他线程的任务执行完，则会以广播的方式通知所有调用 await() 方法阻塞等待的线程

countDown()——-计数器减1

当任务线程任务执行完毕，调用 countDown() 方法的时候，会对计数器（state）进行减1操作

public void countDown() {
    sync.releaseShared(1);
}
---------------------
public final boolean releaseShared(int arg) {
    //将state减1
    if (tryReleaseShared(arg)) {
        //将之前调用 await() 方法阻塞的线程唤醒，继续检查state是否为0
        doReleaseShared();
        return true;
    }
    return false;
}

tryReleaseShared() 尝试将 state 减1

protected boolean tryReleaseShared(int releases) {
    for (;;) {
        //获取当前state的值
        int c = getState();
        //state=0 直接返回false
        if (c == 0)
            return false;
        //state减1
        int nextc = c-1;
        //cas修改state的值
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

成功修改 state 的值后，将之前调用 await() 方法阻塞的线程唤醒，继续检查state是否为0

通过广播的形式唤醒节点线程具体实现可以阅读

从上面源码中可以看到，state的值在调用 countDown() 方法减1后，后面调用await() 方法并没有加回去，所以 CountDownLantch 所起作用是一次性的。

并发编程