Java并发编程-同步辅助类之CountDownLatch

CountDownLatch是Java Concurrent包下提供的同步辅助类。在完成一组正在其他线程中执行的操作之前，它允许线程一直等待。

和Semaphore类似，它使用一个整数进行初始化，Semaphore中的计算表示可以同步访问共享数据的线程数，CountDownLatch中的计算表示线程要等待的操作数数目。

操作方法

构造函数CountDownLatch(int count)，count表示要等待的操作数的数目。

await()方法，阻塞等待，需要其他线程完成期待的操作，直到count为0。

countDown()方法，当某一个操作完成后，调用此方法，count数减一。

注意

一个countDownLatch的作用只能使用一次，当counDownLatch对象的计数器被初始化之后不能再次初始化或者修改。当调用countDown()方法使count为0时，await()方法阻塞的线程都会被唤醒执行，之后再使用countDown()等方法已经没有用了，CountDownLatch对象也就没有用了。

与Semaphore类或者lock类不同，CountDownLatch类不能保护共享数据，因为它不提供互斥访问，它是用来同步执行多个任务或者线程。

使用实例

package MyThread;

import java.util.concurrent.CountDownLatch;

public class Match {

// 模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。
public static void main(String[] args) throws InterruptedException {

// 开始的倒数锁
final CountDownLatch begin=new CountDownLatch(1) ;
// 结束的倒数锁
final CountDownLatch end=new CountDownLatch(10);
// 十名选手

for (int index = 0; index < 10; index++) {
new Thread(new player(begin, end),"player"+index).start();
}
System.out.println("Game Start");
// begin减一，开始游戏
begin.countDown();
// 等待end变为0，即所有选手到达终点
end.await();
System.out.println("Game Over");

}
}
class player implements Runnable{
// 开始的倒数锁
private  final CountDownLatch begin ;
// 结束的倒数锁
private final CountDownLatch end;

player(CountDownLatch begin,CountDownLatch end){
this.begin=begin;
this.end=end;
}
@Override
public void run() {
// TODO Auto-generated method stub
try {
// 如果当前计数为零，则此方法立即返回。
// 等待
begin.await();
Thread.sleep((long) (Math.random() * 10000));
System.out.println(Thread.currentThread().getName() + " arrived");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 每个选手到达终点时，end就减一
end.countDown();
}
}
}

结果

Game Start

player7 arrived

player2 arrived

player3 arrived

player6 arrived

player4 arrived

player0 arrived

player9 arrived

player1 arrived

player5 arrived

player8 arrived

Game Over