6.1倒计时锁（Countdown Latches）

Countdown Latches会让一个或多个线程处于等待，直到其它线程为它开户“门”；也就是说有空闲的线程出现才行。关键还是在于这些其它的线程会一直执行下去。Countdown Latches是有一个计数器，它会让线程处于等待状态直到计算达到‘0’，而这个计数是在递减的。

     java.util.concurrent.CountDownLatch继承countdown latch的同步器。你初始化地个CountDownLatch实例时，会去执行类的CountDownLatch(intcount)的构造器，count就是用来计数的。如果遇到count的值是不合理的，那么将会抛出java.lang.IllegaArgumentException的错误。

     CountDownLatch也提供以下的方法：

        1）void await(): 强迫让线程处于等待，直到计数值为0，除非线程被打断，那么将会抛出java.lang.InterruptedException的异常栈。当计数为0时，这个方法会立即返回。

        2）boolean await(long timeout,TimeUnit unit):强迫线程处于等待，直到计数值为0，或者指定的timeout的值在规定的时间格式中超时，或者线程被打断，那么将会抛出InterruptedException的异常栈。当计数值为0 时，这个方法会立即返回。当计数值为0时，将会返回true，如果等待超时会返回false。

       3） void countdown()：计数在递减，直到计数为0时，会释放所的有线程。当这个方法被调用，如果计数已经为0时，没什么事会发生。

        4）long getCount()：返回当前的计数，这个方法适合打debug和测试用。

        5）String toString():返回锁的字符串的状态。这个状态包含“Count=”的计数值。

     你将会经常用到countdoen latch去确保你的线程在近似相同的时间里在工作。如下面的例子.

Listing 6-1. 使用Countdown Latch 去触发一个的序的开始。

package com.owen.thread.chapter6;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchDemo
{

	final static int NTHREADS = 3;

	public static void main(String[] args)
	{
		final CountDownLatch startSignal = new CountDownLatch(1);
		final CountDownLatch doneSignal = new CountDownLatch(NTHREADS);
		Runnable r = new Runnable()
		{
			@Override
			public void run()
			{
				try
				{
					report("entered run()");
					startSignal.await(); // wait until told to ...
					report("doing work"); // ... proceed
					Thread.sleep((int) (Math.random() * 1000));
					doneSignal.countDown(); // reduce count on which
					// main thread is ...
				} // waiting
				catch (InterruptedException ie)
				{
					System.err.println(ie);
				}
			}

			void report(String s)
			{
				System.out.println(System.currentTimeMillis() + ": "
						+ Thread.currentThread() + ": " + s);
			}
		};
		ExecutorService executor = Executors.newFixedThreadPool(NTHREADS);
		for (int i = 0; i < NTHREADS; i++)
			executor.execute(r);// calls the executor’s execute() method 3 times
		try
		{
			System.out.println("main thread doing something");
			Thread.sleep(1000); // sleep for 1 second
			startSignal.countDown(); // let all threads proceed
			System.out.println("main thread doing something else");
			doneSignal.await(); // wait for all threads to finish
			executor.shutdownNow();
		} catch (InterruptedException ie)
		{
			System.err.println(ie);
		}
	}
}

Listing6-1默认地创建一对countdownlatch。startSignal的countdown latch阻止任务线程执行，直到主线程为它们准备好去执行，它们才会执行。doneSignal的countdown latch在主线程中一直处于等待状态，直到所有工作的线程都完成后，它才开始执行。

     主线程创建一个运行的run()方法，它会随意地去创建工作线程。

     首先，run()方法会先输出一条信息，然后会调用startSignal的await()的方法，直到countdown latch的计数为0后，线程才会继续。之后，又会执行run()的方法，输出一条信息，输出信息后说明工作线程已经完成了，然后就会休眠一段时间。

     这里关键是run()方法会去执行doneSignal的countDown()的方法去递减计数。一旦这个计数为0，主线程就会等待一会儿然后继续，之后关闭执行器（executor）和结束这个应用。

     创建runnable之后，主线程包含了一个执行器（executor），这个执行器以含有三个线程的线程池为基础。然后调用执行器（executor）的execute()的方法三次，通过runnable去执行线程池中的三个线程。这个应用进入run()的方法，然后执行工作线程。

     主线程输出一条信息后，然后休眠一秒钟去执行其它的工作（给其它的工作一个进入run()方法的机会，和执行startSignal.await()）。执行startSignal的countDown()方法，导致工作线程开始运行。之后又输出一条信息，说明线程已经做了其它的事了，而是在执行doneSignal的await()方法后，等待计数到0，线程才会继续。

     执行上面的例子代码 ，你可能会得到如下相似的结束：

main thread doing something 1494251091309: Thread[pool-1-thread-2,5,main]: entered run() 1494251091310: Thread[pool-1-thread-3,5,main]: entered run() 1494251091311: Thread[pool-1-thread-1,5,main]: entered run() main thread doing something else 1494251092309: Thread[pool-1-thread-3,5,main]: doing work 1494251092309: Thread[pool-1-thread-2,5,main]: doing work 1494251092309: Thread[pool-1-thread-1,5,main]: doing work

源码下载：Git@github.com:owenwilliam/Thread.git