并发编程学习笔记（十九、CountDownLatch源码分析）

目录：

• CountDownLatch是什么
• 为什么要有CountDownLatch
• CountDownLatch源码分析

CountDownLatch是什么

CountDownLatch是一种闭锁，也叫倒数计数器，它可以等待多个线程执行完毕后再执行某一件事情。

比如你app的首页要加载很多个模块，而这些模块又处于不同服务，这时候你就可以开启多个线程去分别调用这些模块；然后你后续的一个操作需要用到刚刚调用的那些服务返回的数据，这时候你就可以用CountDownLatch了。

为什么要有CountDownLatch

针对上面那个问题你可能会说，那直接用Thread.join()不就可以了嘛。当然就简单的场景来说，join()的确就够用了，而CountDownLatch其实也就是对join()的一种扩展，它可以适用于更复杂的场景。

我们通过一段代码来看看为何CountDownLatch的控制粒度更细（为了方便我把两个demo的代码写一块了）。

public class ThreadA extends Thread {

    private CountDownLatch countDownLatch;

    public ThreadA() {
    }

    public ThreadA(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("threadA start...");

        try {
            System.out.println("threadA 开始执行第一个任务...");
            TimeUnit.SECONDS.sleep(1);
            System.out.println("threadA 第一个任务执行完毕...");
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            if (countDownLatch != null) {
                countDownLatch.countDown();
            }
        }

        try {
            System.out.println("threadA 开始执行第二个任务...");
            TimeUnit.SECONDS.sleep(3);
            System.out.println("threadA 第二个任务执行完毕...");
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            // do something...
        }

        System.out.println("threadA end...");
    }

}

public class ThreadB extends Thread {

    private CountDownLatch countDownLatch;

    public ThreadB() {
    }

    public ThreadB(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("threadB start...");

        try {
            System.out.println("threadB 开始执行第一个任务...");
            TimeUnit.SECONDS.sleep(2);
            System.out.println("threadB 第一个任务执行完毕...");
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            if (countDownLatch != null) {
                countDownLatch.countDown();
            }
        }

        try {
            System.out.println("threadB 开始执行第二个任务...");
            TimeUnit.SECONDS.sleep(5);
            System.out.println("threadB 第二个任务执行完毕...");
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            // do something...
        }

        System.out.println("threadB end...");
    }

}

public class JoinTest {

    public static void main(String[] args) throws InterruptedException {
        ThreadA threada = new ThreadA();
        ThreadB threadb = new ThreadB();
        threada.start();
        threadb.start();
        threada.join();
        threadb.join();
        System.out.println("joinTest end...");
    }

}

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(new ThreadA(countDownLatch));
        executorService.submit(new ThreadB(countDownLatch));
        countDownLatch.await();
        System.out.println("countDownLatchTest end...");
        executorService.shutdown();
    }

}

为了方便我直接把countDownLatch.countDown()写到一个thread里面了，哈哈。

首先我们观察ThreadA与ThreadB，可以发现他们分别有两个任务需要完成；如果你的业务场景都是需要在两个线程执行完后才会处理数据，那么join和CountDownLatch都可以实现。

但如果你的场景和上述一样，只要在ThreadA、ThreadB完成第一个任务就可以处理后续逻辑的话，那么你就需要使用到CountDownLatch了；因为join没法处理那种线程只执行到某个节点就能唤醒的操作，它必须要当线程全部执行完后才能够唤醒，这就是为什么说CountDownLatch的控制粒度要比join细的原因了。

CountDownLatch源码分析

如果你把我前面所讲的AQS弄懂，那这个简直就是轻而易举，我这里就不再赘述了（偷懒了，哈哈）。

查阅源码的时候你只要记住它的实现原理就可以了，CountDownLatch可以等待多个线程执行完毕后再执行某一件事情。