【5】Java并发编程：线程同步工具之CountDownLatch类

今天在分享会上接触到了CountDownLatch，完会后自己学习一下。CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。

目录

CountDownLatch是什么？
CountDownLatch如何工作？
在实时系统中的应用场景
应用场景范例

CountDownLatch是什么

概述

CountDownLatch是在java1.5被引入的，跟它一起被引入的并发工具类还有CyclicBarrier、Semaphore、ConcurrentHashMap和BlockingQueue，它们都存在于java.util.concurrent包下。CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。

CountDownLatch是通过一个计数器来实现的（只不过对这个计数器的操作都是原子操作，同时只能有一个线程去操作这个计数器），计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。图形表示如下：

CountDownLatch的伪代码如下所示：

//Main thread start //Create CountDownLatch for N threads //Create and start N threads //Main thread wait on latch //N threads completes there tasks are returns //Main thread resume execution

CountDownLatch如何工作

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

//Constructs a CountDownLatch initialized with the given count.
public void CountDownLatch(int count) {...}

构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。 与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。 其他N 个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调 用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

CountDownLatch类的3个基本元素：

（1）初始值决定CountDownLatch类需要等待的事件的数量。
（2）await() 方法, 被等待全部事件终结的线程调用。
（3）countDown() 方法，事件在结束执行后调用。

当创建 CountDownLatch 对象时，对象使用构造函数的参数来初始化内部计数器。每次调用 countDown() 方法, CountDownLatch 对象内部计数器减一。当内部计数器达到0时， CountDownLatch 对象唤醒全部使用 await() 方法睡眠的线程们。

不可能重新初始化或者修改CountDownLatch对象的内部计数器的值。一旦计数器的值初始后，唯一可以修改它的方法就是之前用的 countDown() 方法。当计数器到达0时， 全部调用 await() 方法会立刻返回，接下来任何countDown() 方法的调用都将不会造成任何影响。

此方法与其他同步方法有这些不同：

CountDownLatch 机制不是用来保护共享资源或者临界区。它是用来同步一个或者多个执行多个任务的线程。它只能使用一次。像之前解说的，一旦CountDownLatch的计数器到达0，任何对它的方法的调用都是无效的。如果你想再次同步，你必须创建新的对象。

CountDownLatch 类有另一种版本的 await() 方法，它是：

await(long time, TimeUnit unit): 此方法会休眠直到被中断； CountDownLatch 内部计数器到达0或者特定的时间过去了。TimeUnit 类包含了:DAYS, HOURS, MICROSECONDS, MILLISECONDS, MINUTES, NANOSECONDS, 和 SECONDS.

在实时系统中的使用场景

让我们尝试罗列出在java实时系统中CountDownLatch都有哪些使用场景。我所罗列的都是我所能想到的。如果你有别的可能的使用方法，请在留言里列出来，这样会帮助到大家。

实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。
开始执行前等待n个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。
死锁检测：一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。

CountDownLatch使用实例

在这个例子中，我模拟了一个应用程序启动类，它开始时启动了n=2个线程类，这些线程将检查外部系统并通知闭锁，并且启动类一直在闭锁上等待着。一旦验证和检查了所有外部服务，那么启动类恢复执行。

import java.util.concurrent.CountDownLatch;


public class Sample {
    /** * 计数器，用来控制线程 * 传入参数2，表示计数器计数为2 */
    private final static int number=2;
    private final static CountDownLatch mCountDownLatch = new CountDownLatch(number);

    /** * 示例工作线程类 */
    private static class WorkingThread extends Thread {
        private final String mThreadName;
        private final int mSleepTime;
        public WorkingThread(String name, int sleepTime) {
            mThreadName = name;
            mSleepTime = sleepTime;
        }

        @Override
        public void run() {
            System.out.println("[" + mThreadName + "] started!");
            try {  
                Thread.sleep(mSleepTime);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }
            mCountDownLatch.countDown();
            System.out.println("[" + mThreadName + "] end!"); 
        }
    }

    /** * 示例线程类 */
    private static class SampleThread extends Thread {

        @Override
        public void run() {
            System.out.println("[SampleThread] started!");
            try {
                // 会阻塞在这里等待 mCountDownLatch 里的count变为0；
                // 也就是等待另外的WorkingThread调用countDown()
                mCountDownLatch.await();
            } catch (InterruptedException e) {

            }
            System.out.println("[SampleThread] end!");
        }
    }

    public static void main(String[] args) throws Exception {
        // 最先run SampleThread
        new SampleThread().start();
        // 运行两个工作线程
        // 工作线程1运行5秒
        new WorkingThread("WorkingThread1", 5000).start();
        // 工作线程2运行2秒
        new WorkingThread("WorkingThread2", 2000).start();
    }
}

number=2时运行结果如下：

[SampleThread] started!
[WorkingThread1] started!   mCountDownLatch.getCount()=2
[WorkingThread2] started!   mCountDownLatch.getCount()=2
[WorkingThread2] end!   mCountDownLatch.getCount()=1
[WorkingThread1] end!   mCountDownLatch.getCount()=0
[SampleThread] end!

number=3时运行结果如下：

[SampleThread] started!
[WorkingThread1] started!   mCountDownLatch.getCount()=3
[WorkingThread2] started!   mCountDownLatch.getCount()=3
[WorkingThread2] end!   mCountDownLatch.getCount()=2
[WorkingThread1] end!   mCountDownLatch.getCount()=1

number=1时运行结果如下：

[SampleThread] started!
[WorkingThread1] started!   mCountDownLatch.getCount()=1
[WorkingThread2] started!   mCountDownLatch.getCount()=1
[SampleThread] end!
[WorkingThread2] end!   mCountDownLatch.getCount()=0
[WorkingThread1] end!   mCountDownLatch.getCount()=0

参考致谢：

1 http://www.importnew.com/15731.html
2 http://blog.csdn.net/junshuaizhang/article/details/39580751
3 http://www.cnblogs.com/flyme/p/4568063.html