「java.util.concurrent并发包9」之 CountDownLatch

一 概述

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

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

CountDownLatch.java类中定义的构造函数：

public void CountDownLatch(int count) {...}

构造器中的计数值count实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。

与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用countDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。

其他N个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象已经完成了各自的任务。这种通知机制是通过 countDownLatch.countDown()方法来完成的；每调用一次这个方法，count值就减1。所以当N个线程都调用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

 

 

二 使用场景

1. 实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。

2. 开始执行前等待n个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。

(延伸：第二个容易想到，第一个还是挺别致的～)

 

 

三 代码实例

描述: 在这个例子中，我们有一个应用调用主类，所有外部系统准备(数据，资源，网络准备等)结束后通知闭锁，主类一致在闭锁等待，直到所有外部准备完成。

抽象类定义: 抽象准备接口(抽象类)

public abstract class BasePreparer implements Runnable {

    private CountDownLatch countDownLatch;

    private String prepareName;

    private boolean prepareDone;

    public BasePreparer(String prepareName, CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
        this.prepareName = prepareName;
        this.prepareDone = false;
    }

    protected abstract void prepare();

    @Override
    public void run() {
        try {
            prepare();
            prepareDone = true;
        } catch (Exception e) {
            prepareDone = false;
        } finally {
            if (countDownLatch != null) {
                countDownLatch.countDown();
            }
        }
    }

    public String getPrepareName() {
        return prepareName;
    }

    public boolean isPrepareDone() {
        return prepareDone;
    }
}

实现类1: 模拟数据准备(后面2，3类似，只是成员变量简单变化)

public class DataPreparer extends BasePreparer {

    public DataPreparer(CountDownLatch countDownLatch) {
        super("data prepare", countDownLatch);
    }

    @Override
    protected void prepare() {
        System.out.println(this.getPrepareName() + "is doing");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getPrepareName() + "is done");
    }
}

实现类2: 模拟网络准备

public class NetworkPreparer extends BasePreparer {

    public NetworkPreparer(CountDownLatch countDownLatch) {
        super("network prepare", countDownLatch);
    }

    @Override
    protected void prepare() {
        System.out.println(this.getPrepareName() + "is doing");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getPrepareName() + "is done");
    }
}

实现类3: 模拟资源准备

public class ResourcePreparer extends BasePreparer {

    public ResourcePreparer(CountDownLatch countDownLatch) {
        super("resource prepare", countDownLatch);
    }

    @Override
    protected void prepare() {
        System.out.println(this.getPrepareName() + "is doing");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getPrepareName() + "is done");
    }
}

主调用类

public class CountDownLatchMain {

    private static final int LATCH_NUMBER = 3;

    public static void main(String[] args) throws InterruptedException {

        List<BasePreparer> preparerList = Lists.newArrayListWithExpectedSize(LATCH_NUMBER);
        CountDownLatch countDownLatch = new CountDownLatch(LATCH_NUMBER);

        preparerList.add(new ResourcePreparer(countDownLatch));
        preparerList.add(new DataPreparer(countDownLatch));
        preparerList.add(new NetworkPreparer(countDownLatch));

        ExecutorService executorService = Executors.newFixedThreadPool(LATCH_NUMBER);
        preparerList.forEach(executorService::execute);
        countDownLatch.await();

        List<BasePreparer> readyList = preparerList.stream().filter(BasePreparer::isPrepareDone).collect(Collectors.toList());
        System.out.println(readyList.size() == LATCH_NUMBER);

    }
}

运行结果

resource prepareis doing
network prepareis doing
data prepareis doing
network prepareis done
data prepareis done
resource prepareis done
true