Java中的CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作。

假如，我们现在有这样一个需求，我们需要解析一个sheet中的数据，此时我们可以考虑多线程，一个线程解析一个sheet，当所有线程解析完sheet后，再进行统计。学过多线程的我们可以想到使用join方法解决。

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程A解析完成");
        }
    };
    Thread t2 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程B解析完成");
        }
    };
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("所有线程都已经解析完成");
}

上述代码就是启动两个线程去解析sheet，当线程1和线程2都执行完后，输出所有线程都解析完成

可以看到，线程A和线程B都执行完后，才输出所有线程解析完成。

问题来了，join方法用于让当前线程等待join线程执行结束。其实现原理是不停检查join线程是否存活。如果join线程存活则让当前线程永远等待。直到join线程中止后，线程的this.notifyAll方法会被调用，唤醒其他线程。

在JDK1.5的并发包里提供的CountDownLatch也能实现join的功能，并且比join的功能更多。

下来看看CountDownLatch是如何实现的

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(2);
    Thread t1 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程A解析完成");
            latch.countDown();
        }
    };
    Thread t2 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程B解析完成");
            latch.countDown();
        }
    };
    t1.start();
    t2.start();
    latch.await();
    System.out.println("所有线程都已经解析完成");
}

CountDownLatch的构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完成，这里就传入N。

await方法相当于一道屏障，所有线程都会被阻挡在屏障外面，直到你传入的N变为0，。而调用一次countDown方法，N就会减1。当N变为0时，屏障就会消失。

如果某个线程处理的比较慢，我们不可能让主线程一直等待着，所以可以使用另外一个带指定时间的await方法，如果在特等的的时间内没有等到线程，就会不再阻塞当前线程。

getCount方法

    CountDownLatch有一个getCount方法，可以获得还需要几个才能通过屏障的数量。

假如现在你们要开会，假设有三个人，只有当三个人都到达时才能开始

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        System.out.println("准备开会，等待人员到齐");
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("你已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                System.out.println("他已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        Thread t3 = new Thread(){
            @Override
            public void run() {
                System.out.println("我已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        t1.start();
        t2.start();
        t3.start();
        latch.await();
        System.out.println("所有人都到齐了，开始开会");
    }
}

只有当三个人都到达时，才能开始开会。假设有一个来的比较迟呢，那我应该先开始开会，最后一个人来了之后参与其中。

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        System.out.println("准备开会，等待人员到齐");
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("你已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("他已经到了办公室");
                latch.countDown();
                System.out.println("我来迟了，我们继续吧");
            }
        };
        Thread t3 = new Thread(){
            @Override
            public void run() {
                System.out.println("我已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        t1.start();
        t2.start();
        t3.start();
        latch.await(3,TimeUnit.SECONDS);
        if (latch.getCount()>0){
            System.out.println("我们先开始开会");
        }else {
            System.out.println("所有人都到齐了，开始开会");
        }
    }
}

使用getCount和带参数的await即可以实现这种情况。

总结：

   在CountDownLatch对象时需要传入一个int类型的N值，将CountDownLatch.await当做门的话，这个值就代表了需要多少力量才能打开门。可以使用getCount来获得你还需要多少力量才能打开门。每次调用countDown就会将你传入的N减一，如果await方法判断N为0，则门消失。当N不为0时，所有线程都会被挡在门外，为了避免主线程一直等待，可以使用带参数的await方法，当等待指定时间后门还未打开，则门也消失。