Java并发编程-闭锁CountDownLatch

引入《java并发编程实战》里面一段话。

    闭锁是一种同步工具，可以延迟线程的进度直到其到达最终状态，闭锁相当于一扇门，在闭锁到达结束状态之前，这扇门一直是关着的，并且没有任何线程能够通过，当到达结束状态的时候，这扇门会打开并且允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，这扇门将永远保持打开的状态。

    纯看这段不难理解，看一下怎么实现的。CountDownLatch是闭锁实现的一种方式，它里面包含了一个计数器，这个计数器在初始化为需要等待的事件数量（正数）。方法countDown()是用来计数器递减，await()表示线程会一直阻塞直到计数器为0。也就是当计数器为0的时候，所有等待的事件都会全部发生。

    闭锁常与栅栏进行比较，两者关键的区别就是闭锁用于等待的事件（CountDown事件），栅栏用于等待的是其他线程。也就是CountDown事件执行完后，所有之前等待的线程才能继续执行。下面例子中start和end的用法，start闭锁，CountDown事件计数器从1减为0，所有线程开始执行，而end闭锁，CountDown事件计数器从6减为0。计数器在最后一个线程完成后，计数器减为0，才执行后面计时的代码，否则一致阻塞在end.await()这里。

  看一下实例，就拿这个说的比较多的例子，跑步比赛的例子。

public class Runner implements Runnable{
	private int number;
	private CountDownLatch start;
	private CountDownLatch end;
	
	public Runner(int number, CountDownLatch start, CountDownLatch end) {
		this.number = number;
		this.start = start;
		this.end = end;
	}
	
	public void run() {
		try {
			System.out.println(number+"th runner ready!");
			start.await();
			Thread.sleep((long)Math.random()*1000);//随机数,每个选手跑到终点的时间不一样
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			System.out.println(number+"th runner arrived");
			end.countDown();
		}
	}
}

public class RunningRace {
	public static void main(String[] args) {
		final int threadNum = 6;
		CountDownLatch start = new CountDownLatch(1);
		CountDownLatch end = new CountDownLatch(threadNum);
		for (int i = 1; i <= threadNum; i++) {
			new Thread(new Runner(i, start, end)).start();
		}
		try {
			Thread.sleep(1000);// 准备时间
			System.out.println("比赛开始");
			long startTime = System.currentTimeMillis();
			start.countDown();  //计数器递减
			end.await();
			long endTime = System.currentTimeMillis();
			System.out.println("比赛结束,耗时:"+(endTime-startTime));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

1th runner ready!
3th runner ready!
5th runner ready!
2th runner ready!
4th runner ready!
6th runner ready!
比赛开始
1th runner arrived
3th runner arrived
5th runner arrived
6th runner arrived
4th runner arrived
2th runner arrived
比赛结束,耗时:4

    我们在主线程main里面new Thread().start()开启了6个线程,每个线程都启动了，但是每个线程的任务Runner类里面，在执行到start.await()的时候线程阻塞，因为此时的start计数器还是初始化的1。所有的线程并发的，相当于在执行了start.await()的时候，像有一堵墙横向拦住了所有的线程（阻塞所有线程），这也类似于例子中的起跑那条线。当main主线程中执行start.countDown()的时候，计数器减为0。所有的线程放开，同时执行，“比赛开始”。

    end初始化为6，主要是为了对比赛开始到比赛结束计时。主线程会将end传给每个线程的Runner任务类，在Runner类里面任务执行完成，end.countDown()计数器便会减1。主线程main里面end.await()会在这个6线程没有全部执行完的时候，也就是end的计数器减为0的时候，会一致阻塞end.await()这个代码这里。直到最后一个线程任务完成，end计数器减为0，此时也就能算出所有线程中最后一个任务完成的线程的时间。