关于Java多线程和并发运行的学习（四）——之CountDownLatch

CountDownLatch:

犹如倒计时计数器，调用CountDownLatch对象的countDown方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行。可以实现一个人（也可以是多个人）等待其他所有人都来通知他，可以实现一个人通知多个人的效果，类似裁判一声口令，运动员同时开始奔跑，或者所有运动员都跑到终点后裁判才可以公布结果，用这个功能做百米赛跑的游戏程序不错哦！还可以实现一个计划需要多个领导都签字后才能继续向下实施的情况。

CountDownLatch一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

用给定的计数 初始化CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

CountDownLatch是一个通用同步工具，它有很多用途。将计数 1 初始化的CountDownLatch用作一个简单的开/关锁存器，或入口：在通过调用 countDown() 的线程打开入口前，所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。

CountDownLatch 的一个有用特性是，它不要求 调用 countDown 方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await。

在这里看一则代码：

package Multithreading;

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

public class CountdownLatchTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final CountDownLatch cdOrder = new CountDownLatch(1);//1 一声令下，线程都同时开始
		final CountDownLatch cdAnswer = new CountDownLatch(3);//3 3个线程都完成后，再执行下一步
		for (int i = 0; i < 3; i++) {
			Runnable runnable = new Runnable() {
				public void run() {
					try {
						System.out.println("线程" + Thread.currentThread().getName() + "正准备接受命令");
						/*
						 * await():
						 * 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。 
						 * 如果当前计数为零，则此方法立即返回。 
						 * 如果当前计数大于零，则出于线程调度目的，将禁用当前线程，且在发生以下两种情况之一前，该线程将一直处于休眠状态： 
						 * 1.由于调用 countDown() 方法，计数到达零；
						 * 2.或者 其他某个线程中断当前线程。 
						 * 如果当前线程：在进入此方法时已经设置了该线程的中断状态；或者 在等待时被中断， 
						 * 则抛出 InterruptedException，并且清除当前线程的已中断状态。 
						 */
						cdOrder.await();//线程阻塞在这里，main线程开始运行
						System.out.println("线程" + Thread.currentThread().getName() + "已接受命令");
						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("线程" + Thread.currentThread().getName() + "回应命令处理结果");
						cdAnswer.countDown();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			};
			service.execute(runnable);
		}
		try {//main线程
			Thread.sleep((long) (Math.random() * 10000));
			System.out.println("线程" + Thread.currentThread().getName()
					+ "即将发布命令");
			/*
			 * countDown():
			 * 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。 
			 * 如果当前计数大于零，则将计数减少。
			 * 如果新的计数为零，出于线程调度目的，将重新启用所有的等待线程。 
			 * 如果当前计数等于零，则不发生任何操作。 
			 */
			cdOrder.countDown();//将cdOrder置0，启动上面的线程
			System.out.println("线程" + Thread.currentThread().getName()
					+ "已发送命令，正在等待结果");
			cdAnswer.await();//线程阻塞在这里，继续执行上面的线程
			System.out.println("线程" + Thread.currentThread().getName()
					+ "已收到所有响应结果");
		} catch (Exception e) {
			e.printStackTrace();
		}
		service.shutdown();

	}
}

另一种典型用法是，将一个问题分成 N 个部分，用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分，然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后，协调线程就能够通过 await。（当线程必须用这种方法反复倒计数时，可改为使用 CyclicBarrier。）