JDK中提供了幾個(gè)非常有用的并發(fā)工具類，也就是這次要講的四大天王:CountDownLatch,CyclicBarrier,Semaphore,Exchanger。

先來(lái)一張帥照

1.閉鎖CountDownLatch（等待多線程完成）

我們常常在編程的時(shí)候遇到這樣一種需求：開(kāi)辟多個(gè)線程完成某個(gè)計(jì)算任務(wù)，然后等到所有線程計(jì)算完畢后匯總計(jì)算結(jié)果。對(duì)于這種需求，如果我們不適用CountDownLatch的話，可以使用Thread類中的join(()方法。join用于讓當(dāng)前線程等待join線程執(zhí)行結(jié)束。其原理就是不停檢查join線程是否存活，如果join線程存活則讓當(dāng)前線程永遠(yuǎn)等待。知道join線程終止后，線程的this.noeityAll()方法會(huì)被調(diào)用。
使用join的例子如下：

    import java.util.Random;
    
    public class Test {
        public static void main(String[] args) {
            int nThreads = 10;
            Thread[] threads = new Thread[nThreads];
            for(int i = 0;i < nThreads;i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("I am "+Thread.currentThread().getName()+"and starts");
                        try {
                            //模擬計(jì)算任務(wù)耗時(shí)
                            Thread.sleep(new Random().nextInt(1000));
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("I am "+Thread.currentThread().getName()+"and ends");
                    }
                });
                threads[i].start();
            }
            
            // 等待每個(gè)線程執(zhí)行結(jié)束
            for(int j = 0;j < nThreads;j++){
                try {
                    threads[j].join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            // 只有每個(gè)線程都執(zhí)行結(jié)束了，這句話才會(huì)執(zhí)行
            System.out.println("ALL is over");
            
        }
    }

好了，join就到此為止吧，不能讓主角等急了。下面就重點(diǎn)聊一下CountDownLatch。

老規(guī)矩先給一張應(yīng)用CountDownLatch的帥照吧。

從上圖可以看出，CountDownLatch就像是一扇門(mén)，在這上門(mén)門(mén)開(kāi)啟之前，所有的線程都在門(mén)外等待執(zhí)行，當(dāng)打開(kāi)這扇門(mén)的時(shí)候，所有線程可以自由執(zhí)行，但是這扇門(mén)將不會(huì)改變狀態(tài)，因此這扇門(mén)永遠(yuǎn)保持打開(kāi)狀態(tài)。

下面我們介紹一種CountDwonLatch使用的最為經(jīng)典的場(chǎng)景：起始門(mén)，結(jié)束門(mén)。

    public class TestHarness {
        public long timeTasks(int nThreads, final Runnable task)
                throws InterruptedException {
            // 起始門(mén)
            final CountDownLatch startGate = new CountDownLatch(1);
            
            // 結(jié)束門(mén)
            final CountDownLatch endGate = new CountDownLatch(nThreads);
    
            for (int i = 0; i < nThreads; i++) {
                Thread t = new Thread() {
                    public void run() {
                        try {
                            //在起始門(mén)處等待，知道開(kāi)啟起始門(mén)，才會(huì)往下執(zhí)行
                            startGate.await();
                            try {
                                task.run();
                            } finally {
                                //執(zhí)行完后，結(jié)束門(mén)計(jì)數(shù)器減1
                                endGate.countDown();
                            }
                        } catch (InterruptedException ignored) {
                        }
                    }
                };
                t.start();
            }
    
            long start = System.nanoTime();
            //打開(kāi)起始門(mén)，讓所有線程開(kāi)始執(zhí)行
            startGate.countDown();
            
            //在結(jié)束門(mén)上等待，只有所有線程都執(zhí)行完畢后才會(huì)繼續(xù)往下執(zhí)行
            endGate.await();
            long end = System.nanoTime();
            return end - start;
        }
    }

如上，使用兩個(gè)門(mén)：起始門(mén)，結(jié)束門(mén)。起始門(mén)的計(jì)數(shù)器初始值為1，而結(jié)束門(mén)計(jì)數(shù)器的初始值為工作者線程的數(shù)量。每一個(gè)工作者線程首先要做的事就是在起始門(mén)上等待，從而確保所有線程就緒后才開(kāi)始執(zhí)行。而每一個(gè)線程要做的最后一件事情就是調(diào)用結(jié)束門(mén)的counDown方法減1，這能使主線程高效地等待直到所有工作者線程都執(zhí)行完成，因此可以統(tǒng)計(jì)所消耗的時(shí)間。

為什么要使用起始門(mén)使得所有線程等待而不是線程創(chuàng)建后就立即啟動(dòng)呢？獲取我們希望測(cè)試N個(gè)線程并發(fā)執(zhí)行某個(gè)任務(wù)時(shí)需要的時(shí)間，如果在線程創(chuàng)建后就立即啟動(dòng)它們，那么先啟動(dòng)的線程將領(lǐng)先后啟動(dòng)的線程，并且活躍線程數(shù)量會(huì)隨著時(shí)間的推移而增加或者是減少，競(jìng)爭(zhēng)程度也在不斷變化。啟動(dòng)門(mén)將使得主線程能夠同時(shí)釋放所有的工作者線程，而結(jié)束門(mén)則使主線程能夠等待最后一個(gè)線程執(zhí)行完成，而不是順序地等待每一個(gè)線程執(zhí)行完成

2.同步屏障CyclicBarrier（可循環(huán)使用）

CountDownLacth是一次性對(duì)象，一旦進(jìn)入終止?fàn)顟B(tài)，就不能被重置。CyclicBarrier與CountDwonLacth類似，它能阻塞一組線程知道某個(gè)事件發(fā)生。但是這兩者有一個(gè)重要的區(qū)別：對(duì)于CyclicBarrier而言，所有線程必須同時(shí)到達(dá)屏障處才能繼續(xù)執(zhí)行，而對(duì)于CountDownLathc而言，所有線程必須等待某一件事件，當(dāng)該事件發(fā)生時(shí)，線程才能執(zhí)行。

老規(guī)矩，先來(lái)一張帥照

CyclicBarrier有兩個(gè)構(gòu)造方法：

/**
 * @param parties 屏障攔截的線程數(shù)量
 */
public CyclicBarrier(int parties){...}
/**
 * @param parties 屏障攔截的線程數(shù)量
 * @param barrierAction 所有線程到達(dá)屏障時(shí)優(yōu)先執(zhí)行barrierAction
 */
public CyclicBarrier(int parties, Runnable barrierAction){...}

對(duì)于每一個(gè)線程，當(dāng)調(diào)用了await方法就是告訴CyclicBarrier我已經(jīng)到達(dá)了屏障，然后當(dāng)前線程被阻塞。

下面舉一個(gè)實(shí)際應(yīng)用的例子(應(yīng)用自<<java并發(fā)編程的藝術(shù)>>)：在一個(gè)Excel保存了用戶所有銀行流水，每一個(gè)sheet保存一個(gè)賬戶近一年的每筆銀行流水，現(xiàn)在需要統(tǒng)計(jì)用戶的日均銀行流水，先用多線程處理每一個(gè)sheet里的銀行流水，都執(zhí)行完之后，得到每個(gè)sheet的日均銀行流水，最后，在使用barrierA餐廳用這些線程的計(jì)算結(jié)果，計(jì)算出這個(gè)excel的日均銀行流水

    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Random;
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.CyclicBarrier;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    
    public class BrankWaterService implements Runnable{
    
        /**
         * 穿件4個(gè)屏障，處理完之后執(zhí)行當(dāng)前類的run方法
         */
        private CyclicBarrier c = new CyclicBarrier(4,this);
        
        /**
         * 假設(shè)只有4個(gè)sheet,所以啟動(dòng)4個(gè)線程
         */
        private ExecutorService executor = Executors.newFixedThreadPool(4);
        
        /**
         * 保存每個(gè)sheet計(jì)算出來(lái)的銀行流水線結(jié)果(使用<span style="font-family: Arial, Helvetica, sans-serif;">ConcurrentHashMap保證線程安全</span>)
         */
        private Map<String, Integer> sheetBankWaterCount = new ConcurrentHashMap<String, Integer>();
        
        private  void count() {
            for (int i = 0 ;i <4;i++){
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 計(jì)算當(dāng)前sheet的銀行流水線結(jié)果，計(jì)算過(guò)程忽視...
                        sheetBankWaterCount.put(Thread.currentThread().getName(), new Random().nextInt(10));
                            try {
                                //到達(dá)屏障
                                c.await();
                            } catch (BrokenBarrierException e) {
                                e.printStackTrace();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                    }
                });
            }
        }
        
        @Override
        public void run() {
            int result = 0;
            //匯總每一個(gè)sheet計(jì)算的結(jié)果
            for(Entry<String, Integer> sheet  : sheetBankWaterCount.entrySet()){
                result += sheet.getValue();
            }
            System.out.println(result);
        }
        
        public static void main(String[] args) {
            BrankWaterService brankWaterService = new BrankWaterService();
            brankWaterService.count();
        }
    
    }

3.信號(hào)量Semaphore（控制訪問(wèn)資源的線程數(shù)）

如圖，信號(hào)量用于控制同時(shí)刻訪問(wèn)資源的線程數(shù)量。每一線程需要訪問(wèn)資源的時(shí)候就需要獲得一個(gè)訪問(wèn)許可（如果還有的話），并在使用完之后釋放許可，如果沒(méi)有許可，那么acquire將阻塞知道有許可(或者知道被中斷或者操作超時(shí))。release方法將返回一個(gè)許可給信號(hào)量。

下面舉一個(gè)例子（<<java并發(fā)編程的的藝術(shù)>>）:

我們需要讀取幾萬(wàn)個(gè)日志文件，因?yàn)槎际荌O密集型任務(wù)，我么可以啟動(dòng)幾十個(gè)線程并發(fā)地讀取，但是讀取到內(nèi)存后，我們還需要存儲(chǔ)到數(shù)據(jù)庫(kù)中，而數(shù)據(jù)庫(kù)的連接只有10個(gè)，這時(shí)我們必須控制只有10個(gè)線程同時(shí)獲取數(shù)據(jù)庫(kù)連接保存數(shù)據(jù)，否者就會(huì)報(bào)錯(cuò)無(wú)法獲取數(shù)據(jù)庫(kù)連接，這個(gè)時(shí)候就可以使用信號(hào)量來(lái)做流量控制。

    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Semaphore;
    
    
    public class SemaphoreTest {
        private static final int THREAD_cOUNT = 30;
        
        private static ExecutorService pool = Executors.newFixedThreadPool(10);
        
        private static Semaphore s = new Semaphore(10);
        
        public static void main(String[] args) {
            for(int i =0 ;i < THREAD_cOUNT;i++){
                pool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            s.acquire();
                            System.out.println("save data");
                            s.release();
                        } catch (InterruptedException e) {
                        }
                    }
                });
            }
            pool.shutdown();
        }
    }

代碼中雖然有30個(gè)線程，但是只允許10個(gè)并發(fā)執(zhí)行。Semaphore的構(gòu)造方法public Semaphore(int permits)接受一個(gè)整形的數(shù)字，表示可用的許可數(shù)量。 Semaphore(10)表示允許10個(gè)線程獲取許可，那就是最大并發(fā)數(shù)是10。acquire方法獲取一個(gè)許可，使用完之后使用release方法歸還許可。Semaphore類中海油其他的一些方法可以使用，這里就不一一介紹了，大家有興趣可以翻開(kāi)一下JDK文檔看一下或者直接看源代碼。

4.交換者Exchanger（交換數(shù)據(jù)）

Exchanger是一個(gè)用于線程間協(xié)作的工具類。Exchanger用于進(jìn)行線程間的數(shù)據(jù)交換，它提供一個(gè)同步點(diǎn)，在這個(gè)同步點(diǎn)，兩個(gè)線程可以交換彼此的數(shù)據(jù)。這兩個(gè)線程通過(guò)exchange方法交換數(shù)據(jù)，如果第一個(gè)線程先執(zhí)行exchange方法，它會(huì)一直等待第二個(gè)線程也執(zhí)行exchange方法，當(dāng)兩個(gè)線程都到達(dá)同步點(diǎn)時(shí)，這兩個(gè)線程就可以交換數(shù)據(jù)，將本線程的數(shù)據(jù)傳遞給對(duì)方。

這個(gè)工具的應(yīng)用場(chǎng)景其實(shí)不太好找，不過(guò)我們可以考慮這樣一種應(yīng)用場(chǎng)景：校對(duì)工作。比如，我們需要將紙質(zhì)銀行流水通過(guò)人工的方式錄入成電子銀行流水，為了避免錯(cuò)誤，才用AB崗兩人進(jìn)行錄入，錄入到EXCEL后，系統(tǒng)需要加載這兩個(gè)excel，并對(duì)兩個(gè)excel數(shù)據(jù)進(jìn)行校對(duì)，看看錄入是否一致。

這里就不寫(xiě)出上述場(chǎng)景的具體的代碼了，不過(guò)我寫(xiě)了一個(gè)測(cè)試程序用于讓大家理解一下這個(gè)工具：

    import java.util.Random;
    import java.util.concurrent.Exchanger;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ExChangerTest {
        public static void main(String[] args) {
            Exchanger<Integer> exchanger = new Exchanger<Integer>();
            int nThreads = 10;
            ExecutorService pool = Executors.newFixedThreadPool(nThreads);
            // 同時(shí)啟動(dòng)10個(gè)線程，每一個(gè)線程依次休息1,2,3,4...10秒，然后再交換數(shù)據(jù)
            for (int i = 0; i < nThreads; i++) {
                pool.execute(new Work(exchanger, (i + 1)));
            }
            pool.shutdown();
        }
    }
    
    class Work implements Runnable {
        
        // 同步器
        private Exchanger<Integer> exchanger;
    
        // 休息的秒數(shù)
        private int seconds;
    
        public Work(Exchanger<Integer> exchanger, int seconds) {
            this.exchanger = exchanger;
            this.seconds = seconds;
        }
    
        @Override
        public void run() {
            try {
                Thread.sleep(seconds * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 從其他線程交換得來(lái)的的數(shù)據(jù)
            Integer another = null;
            // 本地產(chǎn)生的的數(shù)據(jù)
            Integer localData = null;
            
            //休息指定的時(shí)間后開(kāi)始交換數(shù)據(jù)
            try {
                localData = new Random().nextInt(100);
                another = exchanger.exchange(localData);//交換數(shù)據(jù)的同步點(diǎn)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->>received data is:" + another);
            System.out.println(Thread.currentThread().getName() + "-->>sended data is:" + localData);
        }
    }

這個(gè)程序制定的大致結(jié)果如下：

pool-1-thread-1-->>received data is:43
pool-1-thread-1-->>sended data is:42
pool-1-thread-2-->>received data is:42
pool-1-thread-2-->>sended data is:43
pool-1-thread-4-->>received data is:68
pool-1-thread-4-->>sended data is:8
pool-1-thread-3-->>received data is:8
pool-1-thread-3-->>sended data is:68
pool-1-thread-5-->>received data is:46
pool-1-thread-5-->>sended data is:80
pool-1-thread-6-->>received data is:80
pool-1-thread-6-->>sended data is:46
pool-1-thread-7-->>received data is:98
pool-1-thread-7-->>sended data is:39
pool-1-thread-8-->>received data is:39
pool-1-thread-8-->>sended data is:98
pool-1-thread-10-->>received data is:16
pool-1-thread-10-->>sended data is:56
pool-1-thread-9-->>received data is:56
pool-1-thread-9-->>sended data is:16

其結(jié)果可以看成是5部分：線程1,2為一部分，線程3,4為一部分...線程9,10為一部分。之所以是這樣的結(jié)果，是因?yàn)楫?dāng)?shù)谝粋€(gè)線程執(zhí)行后1s后，需要交換數(shù)據(jù)，但是由于其他線程還沒(méi)有執(zhí)行到同步點(diǎn)，所以線程1在同步點(diǎn)處阻塞，而此時(shí)線程2也已經(jīng)等待了1s,在過(guò)1s后，線程2醒來(lái)，執(zhí)行到同步點(diǎn)，這時(shí)同步器發(fā)現(xiàn)線程1和線程2都已經(jīng)執(zhí)行到了同步點(diǎn)，那么久開(kāi)始交換數(shù)據(jù)，并繼續(xù)執(zhí)行線程中的其他部分(打印交換的數(shù)據(jù))。由于其他線程還在睡眠中，還沒(méi)有執(zhí)行到同步點(diǎn)，所以只有線程1,2交換數(shù)據(jù)。同樣地，線程2,3，...線程9,10也是同樣的規(guī)律去執(zhí)行。所以總的結(jié)果就是每隔2秒相鄰的相個(gè)線程交換數(shù)據(jù)并執(zhí)行完畢。