CountDouwnLatch、CyclicBarrier、Semaphore

CountDownLatch ：
一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 例如，主线程在做一项工作之前需要一系列的准备工作，只有这些准备工作都完成，主线程才能继续它的工作。这些准备工作彼此独立，所以可以并发执行以提高速度。在这个场景下就可以使用 CountDownLatch 协调线程之间的调度了。用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await
方法会一直受阻塞。之后，会释放所有等待的线程，await的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。

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

下面的这个例子可以理解为 F1 赛车的维修过程，只有 startSignal （可以表示停车，可能名字不太贴合）命令下达之后，维修工才开始干活，只有等所有工人完成工作之后，赛车才能继续。

class Driver { // ...  
    void main() throws InterruptedException {  
        CountDownLatch startSignal = new CountDownLatch(1);  
        CountDownLatch doneSignal = new CountDownLatch(N);  
 
        for (int i = 0; i < N; ++i) // create and start threads  
            new Thread(new Worker(startSignal, doneSignal)).start();  
 
        doSomethingElse();            // don't let run yet  
        startSignal.countDown();      // let all threads proceed  
        doSomethingElse();  
        doneSignal.await();           // wait for all to finish  
    }  
}  
 
class Worker implements Runnable {  
    private final CountDownLatch startSignal;  
    private final CountDownLatch doneSignal;  
    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {  
        this.startSignal = startSignal;  
        this.doneSignal = doneSignal;  
    }  
    public void run() {  
        try {  
            startSignal.await();  
            doWork();  
            doneSignal.countDown();  
        } catch (InterruptedException ex) {} // return;  
    }  
 
    void doWork() { ... }  
} 

当 startSignal.await() 会阻塞线程，当 startSignal.countDown() 被调用之后，所有 Worker 线程开始执行 doWork() 方法，所以 Worker。doWork() 是几乎同时开始执行的。当 Worker.doWork() 执行完毕后，调用 doneSignal.countDown()，在所有 Worker 线程执行完毕之后，主线程继续执行。

package com.wl.test.concurrent.cyclicbarrier;

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

/**
 * 
 * @author HardPass
 * 
 */
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) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (BrokenBarrierException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

					System.out.println(Thread.currentThread().getName()
							+ ":终于可以吃饭啦！");

				}
			});

		}
		exec.shutdown();
				
	}
	
	

}