CountDownLatch

監聽某個線程的初始化，等待初始化執行完畢後，通知主線程工作。延遲、阻塞的是主線程，在單個線程中。

CyclicBarrier

針對多個線程、線程池，多個線程初始化準備之後，去操作同一件事件(必須一定要所有準備才可執行，通知各的主線程去執行正常工作)。

package demo2;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent
 
.ExecutorService;
import java.util.concurrent.Executors;
/**
 * Created by liudan on 2017/7/30.
 */
public class DemoCyclicBarrier {
    /**
     * 假設一個場景：3個運動員，當跑步運動員準備好了，才一起出發
     */
    static class Runner implements Runnable {
        private CyclicBarrier CYCLIC_BARRIER;
        private String name;
        public
 
 Runner(CyclicBarrier CYCLIC_BARRIER, String name) {
            this.CYCLIC_BARRIER = CYCLIC_BARRIER;
            this.name = name;
        }
        @Override
        public void run() {
            try {
                Thread.sleep(1000 * (new Random().nextInt(5)));
                System.err.println(name 
 
+ "\t準備好了");
                CYCLIC_BARRIER.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.err.println("Go！");
        }
        public static void main(String[] args) {
            CyclicBarrier CYCLIC_BARRIER = new CyclicBarrier(3);
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            executorService.execute(new Runner(CYCLIC_BARRIER, "1號"));
            executorService.execute(new Runner(CYCLIC_BARRIER, "2號"));
            executorService.execute(new Runner(CYCLIC_BARRIER, "2號"));
            executorService.shutdown();
        }
    }
}
輸出：
1號	準備好了
2號	準備好了
2號	準備好了
Go！
Go！
Go！

public class TestCyclicBarrier {
    private static final int THREAD_NUM = 5;
    
    public static class WorkerThread implements Runnable{
        CyclicBarrier barrier;
        
        public WorkerThread(CyclicBarrier b){
            this.barrier = b;
        }
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try{
                System.out.println("Worker‘s waiting");
                //線程在這裏等待，直到所有線程都到達barrier。
                barrier.await();
                System.out.println("ID:"+Thread.currentThread().getId()+" Working");
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {
            //當所有線程到達barrier時執行
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("Inside Barrier");
                
            }
        });
        
        for(int i=0;i<THREAD_NUM;i++){
            new Thread(new WorkerThread(cb)).start();
        }
    }
}
/*
以下是輸出：
Worker‘s waiting
Worker‘s waiting
Worker‘s waiting
Worker‘s waiting
Worker‘s waiting
Inside Barrier
ID:12 Working
ID:8 Working
ID:11 Working
ID:9 Working
ID:10 Working
*/

12.線程通信CyclicBarrier