在網上看到很多人對於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來說，重點是那個“一個執行緒”

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
所有任務都完成，任務完成

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:終於可以吃飯啦！