瞭解Java併發的工具類——計數器CountDownLatch和CyclicBarrier,信號量Semaphore,線程間交換數據Exchanger

1. 倒計時器CountDownLatch

在多線程協作完成業務功能時，有時候需要等待其他多個線程完成任務之後，主線程才能繼續往下執行業務功能，在這種的業務場景下，通常可以使用Thread類的join方法，讓主線程等待被join的線程執行完之後，主線程才能繼續往下執行。當然，使用線程間消息通信機制也可以完成。其實，java併發工具類中爲我們提供了類似“倒計時”這樣的工具類，可以十分方便的完成所說的這種業務場景。

爲了能夠理解CountDownLatch，舉一個很通俗的例子，運動員進行跑步比賽時，假設有6個運動員參與比賽，裁判員在終點會爲這6個運動員分別計時，每當一個運動員到達終點的時候，對於裁判員來說就少了一個計時任務。直到所有運動員都到達終點了，裁判員的任務也才完成。這6個運動員可以類比成6個線程，當線程調用CountDownLatch.countDown方法時就會對計數器的值減一，直到計數器的值爲0的時候，裁判員（調用await方法的線程）才能繼續往下執行。

下面來看些CountDownLatch的一些重要方法。

先從CountDownLatch的構造方法看起：

public CountDownLatch(int count)

構造方法會傳入一個整型數N，之後調用CountDownLatch的countDown方法會對N減一，知道N減到0的時候，當前調用await方法的線程繼續執行。

CountDownLatch的方法不是很多，將它們一個個列舉出來：

await() throws InterruptedException：調用該方法的線程等到構造方法傳入的N減到0的時候，才能繼續往下執行；
await(long timeout, TimeUnit unit)：與上面的await方法功能一致，只不過這裏有了時間限制，調用該方法的線程等到指定的timeout時間後，不管N是否減至爲0，都會繼續往下執行；
countDown()：使CountDownLatch初始值N減1；
long getCount()：獲取當前CountDownLatch維護的值；

下面用一個具體的例子來說明CountDownLatch的具體用法:

package 併發多線程;

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

/**
 * 倒計時器CountDownLatch
 * @author xjh 2019.12.28
 */
public class CountDownLatch_Demo {
    //表示1個裁判員維護6個選手
    private static CountDownLatch startSignal =new CountDownLatch(1);
    private static CountDownLatch endSingal =new CountDownLatch(6);

    public static void main(String[] args) {
        ExecutorService executorService=Executors.newFixedThreadPool(6);    //創建一個定長線程池(6個線程)
        for (int i=0;i<6;i++){
            executorService.execute(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+" 選手等待裁判響哨。");
                    startSignal.await();	
                    System.out.println(Thread.currentThread().getName()+" 選手正在衝刺。");
                    endSingal.countDown();  //countDownLatch減1
                    System.out.println(Thread.currentThread().getName()+" 選手到達終點。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        try {
            System.out.println("裁判發號施令~");
            startSignal.countDown();
            endSingal.await();
            System.out.println("所有選手到達終點，結束~");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();// 線程池關閉
    }
}

輸出結果：

pool-1-thread-1 選手等待裁判響哨。
pool-1-thread-5 選手等待裁判響哨。
pool-1-thread-4 選手等待裁判響哨。
pool-1-thread-3 選手等待裁判響哨。
pool-1-thread-2 選手等待裁判響哨。
pool-1-thread-6 選手等待裁判響哨。
裁判發號施令~
pool-1-thread-3 選手正在衝刺。
pool-1-thread-2 選手等待裁判響哨。
pool-1-thread-2 選手正在衝刺。
pool-1-thread-2 選手到達終點。
pool-1-thread-3 選手到達終點。
pool-1-thread-6 選手等待裁判響哨。
pool-1-thread-6 選手正在衝刺。
pool-1-thread-1 選手正在衝刺。
pool-1-thread-4 選手正在衝刺。
pool-1-thread-6 選手到達終點。
pool-1-thread-5 選手正在衝刺。
pool-1-thread-5 選手到達終點。
pool-1-thread-4 選手到達終點。
pool-1-thread-1 選手到達終點。
所有選手到達終點，結束~

該示例代碼中設置了兩個CountDownLatch，第一個endSignal用於控制讓main線程（裁判員）必須等到其他線程（運動員）讓CountDownLatch維護的數值N減到0爲止。另一個startSignal用於讓main線程對其他線程進行“發號施令”，startSignal引用的CountDownLatch初始值爲1，而其他線程執行的run方法中都會先通過 startSignal.await()讓這些線程都被阻塞，直到main線程通過調用startSignal.countDown();，將值N減1，CountDownLatch維護的數值N爲0後，其他線程才能往下執行，並且，每個線程執行的run方法中都會通過endSignal.countDown();對endSignal維護的數值進行減一，由於往線程池提交了6個任務，會被減6次，所以endSignal維護的值最終會變爲0，因此main線程在latch.await();阻塞結束，才能繼續往下執行。

另外，需要注意的是，當調用CountDownLatch的countDown方法時，當前線程是不會被阻塞，會繼續往下執行，比如在該例中會繼續輸出pool-1-thread-4 到達終點。

2. 循環柵欄：CyclicBarrier

CyclicBarrier也是一種多線程併發控制的實用工具，和CountDownLatch一樣具有等待計數的功能，但是相比於CountDownLatch功能更加強大。

爲了理解CyclicBarrier，這裏舉一個通俗的例子。開運動會時，會有跑步這一項運動，我們來模擬下運動員入場時的情況，假設有6條跑道，在比賽開始時，就需要6個運動員在比賽開始的時候都站在起點了，裁判員吹哨後才能開始跑步。跑道起點就相當於“barrier”，是臨界點，而這6個運動員就類比成線程的話，就是這6個線程都必須到達指定點了，意味着湊齊了一波，然後才能繼續執行，否則每個線程都得阻塞等待，直至湊齊一波即可。cyclic是循環的意思，也就是說CyclicBarrier當多個線程湊齊了一波之後，仍然有效，可以繼續湊齊下一波。CyclicBarrier的執行示意圖如下：

當多個線程都達到了指定點後，才能繼續往下繼續執行。這就有點像報數的感覺，假設6個線程就相當於6個運動員，到賽道起點時會報數進行統計，如果剛好是6的話，這一波就湊齊了，才能往下執行。**CyclicBarrier在使用一次後，下面依然有效，可以繼續當做計數器使用，這是與CountDownLatch的區別之一。**這裏的6個線程，也就是計數器的初始值6，是通過CyclicBarrier的構造方法傳入的。

下面來看下CyclicBarrier的主要方法：

//等到所有的線程都到達指定的臨界點
await() throws InterruptedException, BrokenBarrierException 

//與上面的await方法功能基本一致，只不過這裏有超時限制，阻塞等待直至到達超時時間爲止
await(long timeout, TimeUnit unit) throws InterruptedException, 
BrokenBarrierException, TimeoutException 

//獲取當前有多少個線程阻塞等待在臨界點上
int getNumberWaiting()

//用於查詢阻塞等待的線程是否被中斷
boolean isBroken()

	
//將屏障重置爲初始狀態。如果當前有線程正在臨界點等待的話，將拋出BrokenBarrierException。
void reset()

另外需要注意的是，CyclicBarrier提供了這樣的構造方法：

public CyclicBarrier(int parties, Runnable barrierAction)

可以用來，當指定的線程都到達了指定的臨界點的時，接下來執行的操作可以由barrierAction傳入即可。

下面用一個簡單的例子，來看下CyclicBarrier的用法，我們來模擬下上面的運動員的例子。

package 併發多線程.計數器;

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

/**
 * CyclicBarrier的簡單運用
 * @author xjh 2019.12.28
 */
public class CyclicBarrier_Demo {
    private static CyclicBarrier cyclicBarrier=new CyclicBarrier(6,()->{
        // 這裏構造函數 指定6個線程到達指定臨界點之後 才能執行下面的print
        System.out.println("所有選手入場，等待裁判發令！！！");
    });

    public static void main(String[] args) {
        System.out.println("選手進場.....");
        ExecutorService executorService= Executors.newFixedThreadPool(6);
        for (int i=0;i<6;i++){
            executorService.execute(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+ "選手準備");
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName()+" 選手出發");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

輸出結果：

選手進場.....
pool-1-thread-2選手準備
pool-1-thread-3選手準備
pool-1-thread-1選手準備
pool-1-thread-4選手準備
pool-1-thread-5選手準備
pool-1-thread-6選手準備
所有選手入場，等待裁判發令！！！
pool-1-thread-2 選手出發
pool-1-thread-4 選手出發
pool-1-thread-3 選手出發
pool-1-thread-1 選手出發
pool-1-thread-6 選手出發
pool-1-thread-5 選手出發

從輸出結果可以看出，當6個選手（線程）都到達了指定的臨界點（barrier）時候，才能繼續往下執行，否則，則會阻塞等待在調用await()處

3. CountDownLatch與CyclicBarrier的比較

CountDownLatch與CyclicBarrier都是用於控制併發的工具類，都可以理解成維護的就是一個計數器，但是這兩者還是各有不同側重點的：

CountDownLatch一般用於某個線程A等待若干個其他線程執行完任務之後，它才執行；而CyclicBarrier一般用於一組線程互相等待至某個狀態，然後這一組線程再同時執行；CountDownLatch強調一個線程等多個線程完成某件事情。CyclicBarrier是多個線程互等，等大家都完成，再攜手共進。
調用CountDownLatch的countDown方法後，當前線程並不會阻塞，會繼續往下執行；而調用CyclicBarrier的await方法，會阻塞當前線程，直到CyclicBarrier指定的線程全部都到達了指定點的時候，才能繼續往下執行；
CountDownLatch方法比較少，操作比較簡單，而CyclicBarrier提供的方法更多，比如能夠通過getNumberWaiting()，isBroken()這些方法獲取當前多個線程的狀態，並且CyclicBarrier的構造方法可以傳入barrierAction，指定當所有線程都到達時執行的業務功能；
CountDownLatch是不能複用的，而CyclicLatch是可以複用的。

4. 信號量Semaphore

Semaphore可以理解爲信號量，用於控制資源能夠被併發訪問的線程數量，以保證多個線程能夠合理的使用特定資源。Semaphore就相當於一個許可證，線程需要先通過acquire方法獲取該許可證，該線程才能繼續往下執行，否則只能在該方法出阻塞等待。當執行完業務功能後，需要通過release()方法將許可證歸還，以便其他線程能夠獲得許可證繼續執行。

Semaphore可以用於做流量控制，特別是公共資源有限的應用場景，比如數據庫連接。假如有多個線程讀取數據後，需要將數據保存在數據庫中，而可用的最大數據庫連接只有10個，這時候就需要使用Semaphore來控制能夠併發訪問到數據庫連接資源的線程個數最多隻有10個。在限制資源使用的應用場景下，Semaphore是特別合適的。

下面來看下Semaphore的主要方法：

//獲取許可，如果無法獲取到，則阻塞等待直至能夠獲取爲止
void acquire() throws InterruptedException 

//同acquire方法功能基本一樣，只不過該方法可以一次獲取多個許可
void acquire(int permits) throws InterruptedException

//釋放許可
void release()

//釋放指定個數的許可
void release(int permits)

//嘗試獲取許可，如果能夠獲取成功則立即返回true，否則，則返回false
boolean tryAcquire()

//與tryAcquire方法一致，只不過這裏可以指定獲取多個許可
boolean tryAcquire(int permits)

//嘗試獲取許可，如果能夠立即獲取到或者在指定時間內能夠獲取到，則返回true，否則返回false
boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException

//與上一個方法一致，只不過這裏能夠獲取多個許可
boolean tryAcquire(int permits, long timeout, TimeUnit unit)

//返回當前可用的許可證個數
int availablePermits()

//返回正在等待獲取許可證的線程數
int getQueueLength()

//是否有線程正在等待獲取許可證
boolean hasQueuedThreads()

//獲取所有正在等待許可的線程集合
Collection<Thread> getQueuedThreads()
另外，在Semaphore的構造方法中還支持指定是夠具有公平性，默認的是非公平性，這樣也是爲了保證吞吐量。

下面用一個簡單的例子來說明Semaphore的具體使用。我們來模擬這樣一樣場景。有一天，班主任需要班上10個同學到講臺上來填寫一個表格，但是老師只准備了5支筆，因此，只能保證同時只有5個同學能夠拿到筆並填寫表格，沒有獲取到筆的同學只能夠等前面的同學用完之後，才能拿到筆去填寫表格。該示例代碼如下：

package 併發多線程.常用的併發工具;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 信號量Semaphore 簡單運用
 * @author xjh 2019.12.28
 */
public class Semaphore_Demo {
    //信號量設置爲5
    private static Semaphore semaphore=new Semaphore(5);

    public static void main(String[] args) {
        ExecutorService executorService= Executors.newFixedThreadPool(10); //定義10個線程
        for (int i=0;i<10;i++){
            executorService.execute(()->{
                try {
                    System.out.println(Thread.currentThread().getName() + "  同學準備獲取筆......");
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "  同學準備獲取到筆......");
                    System.out.println(Thread.currentThread().getName() + "  同學填寫表格......");
                    Thread.sleep(3000);
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName() + "  填寫完表格，歸還了筆！！！！！！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown(); //關閉線程池
    }
}

輸出結果：

pool-1-thread-1  同學準備獲取筆......
pool-1-thread-4  同學準備獲取筆......
pool-1-thread-3  同學準備獲取筆......
pool-1-thread-6  同學準備獲取筆......
pool-1-thread-2  同學準備獲取筆......
pool-1-thread-6  同學準備獲取到筆......
pool-1-thread-7  同學準備獲取筆......
pool-1-thread-3  同學準備獲取到筆......
pool-1-thread-3  同學填寫表格......
pool-1-thread-9  同學準備獲取筆......
pool-1-thread-4  同學準備獲取到筆......
pool-1-thread-5  同學準備獲取筆......
pool-1-thread-1  同學準備獲取到筆......
pool-1-thread-1  同學填寫表格......
pool-1-thread-4  同學填寫表格......
pool-1-thread-8  同學準備獲取筆......
pool-1-thread-6  同學填寫表格......
pool-1-thread-2  同學準備獲取到筆......
pool-1-thread-2  同學填寫表格......
pool-1-thread-10  同學準備獲取筆......
pool-1-thread-3  填寫完表格，歸還了筆！！！！！！
pool-1-thread-7  同學準備獲取到筆......
pool-1-thread-7  同學填寫表格......
pool-1-thread-4  填寫完表格，歸還了筆！！！！！！
pool-1-thread-10  同學準備獲取到筆......
pool-1-thread-10  同學填寫表格......
pool-1-thread-8  同學準備獲取到筆......
pool-1-thread-8  同學填寫表格......
pool-1-thread-5  同學準備獲取到筆......
pool-1-thread-5  同學填寫表格......
pool-1-thread-6  填寫完表格，歸還了筆！！！！！！
pool-1-thread-1  填寫完表格，歸還了筆！！！！！！
pool-1-thread-2  填寫完表格，歸還了筆！！！！！！
pool-1-thread-9  同學準備獲取到筆......
pool-1-thread-9  同學填寫表格......
pool-1-thread-7  填寫完表格，歸還了筆！！！！！！
pool-1-thread-9  填寫完表格，歸還了筆！！！！！！
pool-1-thread-10  填寫完表格，歸還了筆！！！！！！
pool-1-thread-8  填寫完表格，歸還了筆！！！！！！
pool-1-thread-5  填寫完表格，歸還了筆！！！！！！

5. 線程間交換數據的工具–Exchanger

Exchanger是一個用於線程間協作的工具類，用於兩個線程間能夠交換。它提供了一個交換的同步點，在這個同步點兩個線程能夠交換數據。具體交換數據是通過exchange方法來實現的，如果一個線程先執行exchange方法，那麼它會同步等待另一個線程也執行exchange方法，這個時候兩個線程就都達到了同步點，兩個線程就可以交換數據。

Exchanger除了一個無參的構造方法外，主要方法也很簡單：

//當一個線程執行該方法的時候，會等待另一個線程也執行該方法，因此兩個線程就都達到了同步點
//將數據交換給另一個線程，同時返回獲取的數據
V exchange(V x) throws InterruptedException

//同上一個方法功能基本一樣，只不過這個方法同步等待的時候，增加了超時時間
V exchange(V x, long timeout, TimeUnit unit)
    throws InterruptedException, TimeoutException

Exchanger理解起來很容易，這裏用一個簡單的例子來看下它的具體使用。我們來模擬這樣一個情景，在青春洋溢的中學時代，下課期間，男生經常會給走廊裏爲自己喜歡的女孩子送情書，相信大家都做過這樣的事情吧：)。男孩會先到女孩教室門口，然後等女孩出來，教室那裏就是一個同步點，然後彼此交換信物，也就是彼此交換了數據。現在，就來模擬這個情景。

參考資料：
大白話說java併發工具類-CountDownLatch，CyclicBarrier
大白話說java併發工具類-Semaphore，Exchanger