在学习zookeeper相关知识点的时候遇到了一个类叫做CountDownLatch，因为没使用过该类所以不是太理解。为了不至于影响后面的学习，决定先把CountDownLatch学习一番。
1. CountDownLatch的概念
首先字面上翻译过来的意思是倒计时闭锁，翻译过来似乎好理解一些。倒计时即依次减少，锁呢也好理解在编程中经常提到的一个概念，起到了一个同步阻塞的作用。是否如此呢？再看下官网的解释：A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes. 翻译：一种同步辅助，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。(官方文档：docs.oracle.com/javase/7/do…) 详细的说明下，CountDownLatch是在java1.5被引入的，跟它一起被引入的并发工具类还有CyclicBarrier、Semaphore、ConcurrentHashMap和BlockingQueue，它们都存在于java.util.concurrent包下。CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。 CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。总结下就是：CountDownLatch是一种java.util.concurrent包下一个同步工具类，它允许一个或多个线程等待直到在其他线程中一组操作执行完成。
2. CountDownLatch的用法
需要借助CountDownLatch的构造器进行使用，CountDownLatch.java类中定义的构造函数： 构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。 与CountDownLatch的第一次交互是调用CountDownLatch.await() 方法。这样会使得调用该法方法的当前线程在这个方法上阻塞，直到其他线程完成各自的任务调用CountDownLatch.countDown()方法，使CountDownLatch构造方法的参数最终递减为0，受到阻塞的那个线程才会被释放。当然其他的线程必须引用相同的闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调用了这个方法，count的值等于0，然后阻塞线程就能通过await()方法，恢复执行自己的任务。
3. CountDownLatch的使用场景
3.1 实现最大的并行性
注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计算器初始化为1，多个线程在开始执行任务前首先countdownlatch.await()，当主线程调用countDown()时，计数器变为0，多个线程同时被唤醒。
3.2 开始执行前等待n个线程完成各自任务
某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1 countdownLatch.countDown()，当计数器的值变为0时，在CountDownLatch上await()的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。
4. CountDownLatch的注意事项
CountDownLatch是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。
5. CountDownLatch的使用举例
示例一：
public class CountDownLatchTest {
public static void main(String[] args) {
CountDownLatch begin = new CountDownLatch(1);
CountDownLatch end = new CountDownLatch(2);
for (int i=0; i<2; i++){
Thread thread = new Thread(new Player(begin,end));
thread.start();
}
try {
System.out.println("the race begin");
begin.countDown();
end.await();
System.out.println("the race end");
} catch(Exception e){
e.printStackTrace();
}
}
}
/**
* 选手
*/
class Player implements Runnable{
private CountDownLatch begin;
private CountDownLatch end;
Player(CountDownLatch begin,CountDownLatch end){
this.begin = begin;
this.end = end;
}
public void run() {
try {
begin.await();
System.out.println(Thread.currentThread().getName() + " arrived !");;
end.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果如下：
为方便理解，建议将begin.await()、begin.countDown()、end.await()、end.countDown()选择某一个注释掉在运行，这样很容易理解了。
示例二：
在这个例子中，我模拟了一个应用程序启动类，它开始时启动了n个线程类，这些线程将检查外部系统并通知闭锁，并且启动类一直在闭锁上等待着。一旦验证和检查了所有外部服务，那么启动类恢复执行。
BaseHealthChecker.java： 这个类是一个Runnable，负责所有特定的外部服务健康的检测。它删除了重复的代码和闭锁的中心控制代码。
public abstract class BaseHealthChecker implements Runnable {
private CountDownLatch _latch;
private String _serviceName;
private boolean _serviceUp;
// Get latch object in constructor so that after completing the task, thread can countDown() the latch
public BaseHealthChecker(String serviceName, CountDownLatch latch) {
this._latch = latch;
this._serviceName = serviceName;
this._serviceUp = false;
}
@Override
public void run() {
try {
verifyService();
_serviceUp = true;
} catch (Throwable t) {
t.printStackTrace(System.err);
_serviceUp = false;
} finally {
if (_latch != null) {
_latch.countDown();
}
}
}
public String getServiceName() {
return _serviceName;
}
public boolean isServiceUp() {
return _serviceUp;
}
public abstract void verifyService();
}
NetworkHealthChecker.java： 这个类继承了BaseHealthChecker，实现了verifyService()方法。DatabaseHealthChecker.java和CacheHealthChecker.java除了服务名和休眠时间外，与NetworkHealthChecker.java是一样的。
public class NetworkHealthChecker extends BaseHealthChecker {
public NetworkHealthChecker (CountDownLatch latch) {
super("Network Service", latch);
}
@Override
public void verifyService() {
System.out.println("Checking " + this.getServiceName() + " ...");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getServiceName() + " is UP");
}
}
ApplicationStartupUtil.java： 这个类是一个主启动类，它负责初始化闭锁，然后等待，直到所有服务都被检测完。
public class ApplicationStartupUtil {
//List of service checkers
private static List<BaseHealthChecker> _services;
//This latch will be used to wait on
private static CountDownLatch _latch;
private final static ApplicationStartupUtil INSTANCE = new ApplicationStartupUtil();
public static ApplicationStartupUtil getInstance() {
return INSTANCE;
}
public static boolean checkExternalServices() throws Exception {
//Initialize the latch with number of service checkers
_latch = new CountDownLatch(3);
//All add checker in lists
_services = new ArrayList<BaseHealthChecker>();
_services.add(new NetworkHealthChecker(_latch));
_services.add(new CacheHealthChecker(_latch));
_services.add(new DatabaseHealthChecker(_latch));
//Start service checkers using executor framework
Executor executor = Executors.newFixedThreadPool(_services.size());
for (final BaseHealthChecker v : _services) {
executor.execute(v);
}
//Now wait till all services are checked
_latch.await();
//Services are file and now proceed startup
for(final BaseHealthChecker v : _services) {
if(!v.isServiceUp()) {
return false;
}
}
return true;
}
}
现在你可以写测试代码去检测一下闭锁的功能了。
public class Main {
public static void main(String[] args) {
boolean result = false;
try {
result = ApplicationStartupUtil.checkExternalServices();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("External services validation completed !! Result was :: "+ result);
}
}
