java并发编程系列之CountDownLatch的使用

说到定时器，我们就会想到java中的Timer。在jdk1.5中，也提供了一个类似定时器功能的类CountDownLatch，只不过两者有些区别，CountDownLatch类同一时刻只能由一个线程去操作也就是说，在多线程并发下，同时只能由其中的一个线程去操作这个计时器。CountDownLatch 的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如这个想要继续往下执行的任务调用一个 CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的 countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。看到这里，大家肯定想起了我们前面的那个搞活动的例子，上次是用CyclicBarrier来实现的，下面我们就用CountDownLatch来实现这个例子。示例代码如下：

/**
* 描述：CountDownLatch的使用示例
* @author chhliu
* 创建时间：2015-9-17 下午9:41:37
*/
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
// 新建一个计数器，初始值为5
final CountDownLatch latch = new CountDownLatch(5);

/*
* 新建5个线程，此处线程数必须和CountDownLatch中设置的倒数个数一致，否则会出问题
* 如果此处设置成4的话，就会一直等待，直到第5个线程到来，但没有第5个线程，就会一直死等
*/
ExecutorService service = Executors.newFixedThreadPool(5);
// 提交5个任务
for (int i = 0; i < 5; i++) {
// 假设每隔1秒中，有一个人到达
Thread.sleep(1000);
service.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName()
+ "到达园博园了！");
// 计数器减1
latch.countDown();
// 如果计数器不为0，则线程一直阻塞
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("所有的人都到达了……");
}
});
}
// 释放线程池资源
service.shutdown();
}
}
测试结果如下：

pool-1-thread-1到达园博园了！
pool-1-thread-2到达园博园了！
pool-1-thread-3到达园博园了！
pool-1-thread-4到达园博园了！
pool-1-thread-5到达园博园了！
所有的人都到达了……
所有的人都到达了……
所有的人都到达了……
所有的人都到达了……
所有的人都到达了……

从测试结果来看，每调用一次countDown方法，则计数器减1，并且线程会被阻塞，知道为0，所有的线程才被唤醒，继续往下走，记住，此处是一次唤醒全部的线程。下面我们来看下这个类的原型：

public class CountDownLatch {
/**
* Synchronization control For CountDownLatch.
* Uses AQS state to represent count.
*/
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
public int tryAcquireShared(int acquires) {
return getState() == 0? 1 : -1;
}

public boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}

private final Sync sync;
// 构造方法，同时指定计数器的个数
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
// 阻塞线程
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
// 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。如果当前计数为零，则此方法立刻返回 true 值。如果当前计数大于零，则出于线程调度目的，将阻塞当前线程，且在超时或者被中断之前，该线程将一直处于阻塞状态：
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
// 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少。如果新的计数为零，出于线程调度目的，将重新启用所有的等待线程。 如果当前计数等于零，则不发生任何操作。
public void countDown() {
sync.releaseShared(1);
}
// 获取当前剩下的计数个数
public long getCount() {
return sync.getCount();
}
}

前面说到，如果线程数设置成4，而计数器设置成5，那么会发生死等的现象，如果我们不想死等，可以使用await(long timeout, TimeUnit unit)方法，中断被阻塞的线程，使整个流程继续往下走，测试结果如下：

pool-1-thread-1到达园博园了！
pool-1-thread-2到达园博园了！
pool-1-thread-3到达园博园了！
pool-1-thread-4到达园博园了！
所有的人都到达了……
pool-1-thread-1到达园博园了！
所有的人都到达了……
所有的人都到达了……
所有的人都到达了……
所有的人都到达了……

从测试结果来看，pool-1-thread-1这个线程被中断了，并且再一次的被启用。