多线程CountDownLatch和CyclicBarrier的区别 以及举例

在网上看到很多人对于CountDownLatch和CyclicBarrier的区别简单理解为CountDownLatch是一次性的，而CyclicBarrier在调用reset之后还可以继续使用。那如果只是这么简单的话，我觉得CyclicBarrier简单命名为ResetableCountDownLatch好了，显然不是的。
我的理解是，要从他们的设计目的去看这两个类。javadoc里面的描述是这样的。

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

可能是我的英语不够好吧， 我感觉从这个javadoc里面要准确理解他们的差异还是不容易的。
我的理解是

CountDownLatch : 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。   CyclicBarrier        : N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。
这样应该就清楚一点了，对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待， 而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。

CountDownLatch 是计数器, 线程完成一个就记一个, 就像 报数一样, 只不过是递减的.

而CyclicBarrier更像一个水闸, 线程执行就想水流, 在水闸处都会堵住, 等到水满(线程到齐)了, 才开始泄流.

CountDownLatch：

package com.guozz.test.testCountDownLatchAndCyclicBarrier;

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

/**
 * 
 * @author paul
 * 
 * CountDownLatch 很适合用来将一个任务分为n个独立的部分，等这些部分都完成后继续接下来的任务，
 * CountDownLatch 只能出发一次，计数值不能被重置。
 * 
 * 基于CountDownLatch 的模拟项目，一个项目可以分为多个模块，只有但这些模块都完成后才可以继续下一步的工作。
 * 
 * 
 *	countDown方法，当前线程调用此方法，则计数减一
	await方法，调用此方法会一直阻塞当前线程，直到计时器的值为0
	
	executorService.shutdown() 并不是终止线程的运行，而是禁止在这个Executor中添加新的任务
	 void shutdown()
    	启动一个关闭命令，不再接受新任务，当所有已提交任务执行完后，就关闭。如果已经关闭，则调用没有其他作用。
    	抛出：
        SecurityException - 如果安全管理器存在并且关闭，此 ExecutorService 可能操作某些不允许调用者修改的线程
                       （因为它没有保持 RuntimePermission("modifyThread")），或者安全管理器的 checkAccess 方法拒绝访问。
 */
public class CountDownLatchTest {
	//定义计数器
	static  final int  SIZE=20;
	
	public static void main(String[] args) {
		CountDownLatch latch = new CountDownLatch(SIZE);
		Random random = new Random();
		ExecutorService executorService = Executors.newCachedThreadPool();
		//让等待所有子线程执行完毕
		Controller controller = new Controller(latch);
		executorService.execute(controller);
		
		//将SIZE个小任务去执行，多个子线程任务
		for(int i=0;i<SIZE;i++){
			executorService.execute(new Module(latch,"模块"+(i+1),random.nextInt(2000)));
		}
		executorService.shutdown();//并不是终止线程的运行，而是禁止在这个Executor中添加新的任务
	}
}


class Module implements Runnable{
	
	private CountDownLatch latch;
	
	private String name;
	
	private int random;
	
	public Module(CountDownLatch latch,String name,int random){
		this.latch=latch;
		this.name=name;
		this.random=random;
	}

	@Override
	public void run() {
		work();		
		latch.countDown(); //当前线程调用此方法，则计数减一
		
	}

	private void work() {
		 try {
			TimeUnit.MILLISECONDS.sleep(random);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}  
	       System.out.println(name + " 完成，耗时:" + random);
	}
}


class Controller implements Runnable{
	
	private CountDownLatch latch;
	
	public Controller(CountDownLatch latch){
		super();
		this.latch=latch;
	}

	@Override
	public void run() {
		try {
			latch.await();  //调用此方法会一直阻塞当前线程，直到计时器的值为0
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("所有任务都完成，任务完成");			
	}
}

模块5 完成，耗时:48
模块20 完成，耗时:291
模块7 完成，耗时:300
模块6 完成，耗时:358
模块12 完成，耗时:507
模块3 完成，耗时:543
模块2 完成，耗时:603
模块16 完成，耗时:727
模块17 完成，耗时:1224
模块14 完成，耗时:1309
模块4 完成，耗时:1448
模块11 完成，耗时:1515
模块8 完成，耗时:1556
模块10 完成，耗时:1756
模块13 完成，耗时:1844
模块15 完成，耗时:1844
模块19 完成，耗时:1848
模块1 完成，耗时:1882
模块18 完成，耗时:1924
模块9 完成，耗时:1985
所有任务都完成，任务完成

CyclicBarrier

package com.guozz.test.testCountDownLatchAndCyclicBarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 
 * @author HardPass
 * 
 * CyclicBarrier:一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。
 * 	在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。
 * 因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
	CyclicBarrier可以多次重复使用
 */
public class CyclicBarrierTest_RelayRace {

	public static void main(String[] args) throws InterruptedException {
		
		ExecutorService exec = Executors.newCachedThreadPool();
		
		final CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {

			@Override
			public void run() {
				System.out.println("好了，大家可以去吃饭了……"  );
			}
		});		
		
		System.out.println("要吃饭，必须所有人都到终点，oK?");				
		System.out.println("不放弃不抛弃！");
		
		for (int i = 0; i < 4; i++) {
			exec.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName() + ":Go");
					try {
						Thread.sleep((long) (2000 * Math.random()));
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+ ":我到终点了");
					try {
						barrier.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					} catch (BrokenBarrierException e) {
						e.printStackTrace();
					}
					
					System.out.println(Thread.currentThread().getName()+ ":终于可以吃饭啦！");

				}
			});

		}
		exec.shutdown();
				
	}
	
	

}

要吃饭，必须所有人都到终点，oK?
不放弃不抛弃！
pool-1-thread-1:Go
pool-1-thread-2:Go
pool-1-thread-3:Go
pool-1-thread-4:Go
pool-1-thread-3:我到终点了
pool-1-thread-4:我到终点了
pool-1-thread-1:我到终点了
pool-1-thread-2:我到终点了
好了，大家可以去吃饭了……
pool-1-thread-2:终于可以吃饭啦！
pool-1-thread-3:终于可以吃饭啦！
pool-1-thread-4:终于可以吃饭啦！
pool-1-thread-1:终于可以吃饭啦！