同步工具类之CountDownLatch倒数计数器

   CountDownLatch类在java.util.concurrent包下，一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。犹如倒计时计数器，调用CountDownLatch对象的countDown方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行。这直接通过代码来说明CountDownLatch的作用，可以实现一个人（也可以是多个人）等待其他所有人都来通知他，这犹如一个计划需要多个领导都签字后才能继续向下实施，还可以实现一个人通知多个人的效果，类似裁判一声口令，运动员同时开始奔跑。

构造方法

public CountDownLatch(int count)构造一个用给定计数初始化的CountDownLatch。 

参数：
count - 在线程能通过 await() 之前，必须调用 countDown() 的次数 
抛出： IllegalArgumentException - 如果 count 为负

方法摘要

 void await() 
          使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。 
 boolean await(long timeout, TimeUnit unit) 
          使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。 
 void countDown() 
          递减锁存器的计数，如果计数到达零，则释放所有等待的线程。 
 long getCount() 
          返回当前计数。 
 String toString() 
          返回标识此锁存器及其状态的字符串。 

 

    用给定的计数 count 初始化 CountDownLatch 。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier 。CountDownLatch 是一个通用同步工具，它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器，或入口：在通过调用 countDown() 的线程打开入口前，所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。CountDownLatch 的一个有用特性是，它不要求调用 countDown 方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await，如下代码：

/**
 * Huisou.com Inc.
 * Copyright (c) 2011-2012 All Rights Reserved.
 */

package thread;

import java.util.concurrent.CountDownLatch;

/**
 * @description
 * 
 * @author chenzehe
 * @email [e-mail]
 * @create 2013-1-10 下午08:24:52
 */

public class CountDownLatchTest {
	public static void main(String[] args) throws InterruptedException {
		int N = 10;
		CountDownLatch startSignal = new CountDownLatch(1);
		CountDownLatch doneSignal = new CountDownLatch(N);
		for (int i = 0; i < N; ++i) {
			new Thread(new Worker(startSignal, doneSignal)).start();
		}
		Thread.sleep(2000);
		System.out.println("before startSignal.countDown...");
		startSignal.countDown(); // let all threads proceed
		Thread.sleep(2000);
		System.out.println("finish startSignal.countDown...");
		doneSignal.await(); // wait for all to finish
		System.out.println("wait for all to finish...");
	}
}

class Worker implements Runnable {
	private final CountDownLatch	startSignal;
	private final CountDownLatch	doneSignal;
	
	Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
		this.startSignal = startSignal;
		this.doneSignal = doneSignal;
	}
	
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName() + " come run method...");
			startSignal.await();
			doWork();
			doneSignal.countDown();
			System.out.println(Thread.currentThread().getName() + " left run method...");
		}
		catch (InterruptedException ex) {
		}
	}
	
	void doWork() {
		System.out.println(Thread.currentThread().getName() + " do work...");
	}
}

Thread-0 come run method...
Thread-1 come run method...
Thread-2 come run method...
Thread-4 come run method...
Thread-6 come run method...
Thread-8 come run method...
Thread-3 come run method...
Thread-5 come run method...
Thread-7 come run method...
Thread-9 come run method...
before startSignal.countDown...
Thread-0 do work...
Thread-0 left run method...
Thread-1 do work...
Thread-1 left run method...
Thread-2 do work...
Thread-2 left run method...
Thread-6 do work...
Thread-6 left run method...
Thread-4 do work...
Thread-4 left run method...
Thread-8 do work...
Thread-8 left run method...
Thread-3 do work...
Thread-3 left run method...
Thread-5 do work...
Thread-5 left run method...
Thread-7 do work...
Thread-7 left run method...
Thread-9 do work...
Thread-9 left run method...
finish startSignal.countDown...
wait for all to finish...
 

 它不阻塞线程的方法继续执行，所以上面一直打印come run method...，但是到wait方法的时候就阻塞了，等着主线程执行startSignal.countDown();因为startSignal的值count设置为1，所以只需要执行一次就会执行do work...，此时主线程中的doneSignal.await();方法已经被阻塞，只有等到doneSignalcount为0时才往下执行，也就是在子线程中执行了N次doneSignal.countDown();方法。