java併發程式設計的藝術筆記第八章——java中的併發工具類

weixin_34320159發表於2017-08-26
Java程式設計筆記

在JDK的併發包裡面提供了幾個非常有用的併發工具，CountDownLatch、CyclicBarrier、Semaphore工具類提供了一種併發控制流程的手段，Exchanger工具類則提供了線上程間交換資料的一種手段。

1、等待多執行緒完成的CountDownLatch

CountDownLatch是一個同步輔助類，在完成一組正在其他執行緒中執行的操作之前，它執行一個或者多個執行緒一直處於等待狀態。
CountDownLatch中有兩個關鍵的方法

public void countDown() {}

public boolean await(long timeout, TimeUnit unit){}

CountDownLatch是一個計數器，在它的構造方法中需要指定一個值，用來設定計數的次數。
每呼叫一次countDown()方法，數值便會減一，CountDownLatch會一直阻塞著呼叫await()方法的執行緒
直到計數器的值變為0。
設想有這樣一個功能需要Thread1、Thread2、Thread3、Thread4四條執行緒分別統計C、D、E、F
四個盤的大小，所有執行緒都統計完畢交給主執行緒去做彙總，利用CountDownLatch來完成就非常輕鬆。

在實際的專案開發中，有類似的應用場景用CountDownLatch來實現也非常簡單實用。

package com.dreyer.javadoc.thread;

import java.util.Date;
import java.util.Random;
import java.util.concurrent.*;

/**
 * @description CountDownLatch
 * @author: 會跳舞的機器人
 * @date: 16/5/14 下午11:41
 */
public class CountDownLatchDemo {
    /**
     *
     */
    private static CountDownLatch countDownLatch = new CountDownLatch(4);

    /**
     * 執行緒池
     */
    private static ExecutorService executor = Executors.newFixedThreadPool(4);

    /**
     * 開啟的執行緒數
     */
    private static int THREAD_COUNT = 4;


    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.execute(new Runnable() {
                public void run() {
                    try {
                        // 模擬業務邏輯的耗時
                        int timer = new Random().nextInt(5);
                        TimeUnit.SECONDS.sleep(timer);

                        System.out.printf("%s時完成磁碟的統計任務,耗費%d秒.\n", new Date().toString(), timer);
                        // 業務處理完成之後,計數器減一
                        countDownLatch.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        // 主執行緒一直被阻塞,直到countDownLatch的值為0
        countDownLatch.await();
        System.out.printf("%s時全部任務都完成,執行合併計算.\n", new Date().toString());
        executor.shutdown();
    }
}

程式輸出：

Fri Aug 18 15:20:14 CST 2017時完成磁碟的統計任務,耗費0秒.
Fri Aug 18 15:20:15 CST 2017時完成磁碟的統計任務,耗費1秒.
Fri Aug 18 15:20:16 CST 2017時完成磁碟的統計任務,耗費2秒.
Fri Aug 18 15:20:17 CST 2017時完成磁碟的統計任務,耗費3秒.
Fri Aug 18 15:20:17 CST 2017時全部任務都完成,執行合併計算.

從輸出中我們可以看出“執行合併計算”這句是在所有執行緒完成統計任務之後才輸出的。

2、同步屏障CyclicBarrier

CyclicBarrier要做的事情是，讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，屏障才會開門，所有被屏障攔截的執行緒才會繼續執行。

CyclicBarrier初始化的時候，設定一個屏障數。執行緒呼叫await()方法的時候，這個執行緒就會被阻塞，當呼叫await()的執行緒數量到達屏障數的時候，主執行緒就會取消所有被阻塞執行緒的狀態。
其構造方法如下：

public CyclicBarrier(int parties){}

引數parties則為初始化時的屏障數
CyclicBarrier還提供一個更高階的建構函式

public CyclicBarrier(int parties, Runnable barrierAction) {}

用於線上程到達屏障時，優先執行barrierAction，方便處理更復雜的業務場景
例如，用一個Excel儲存了使用者所有的銀行流水，每個sheet儲存一個賬戶近一年的每筆交易流水，現在需要統計使用者的日均交易流水，先用多執行緒處理每個sheet裡的交易流水，都處理完後，得到每個sheet的日均交易流水，最後再用barrierAction用這些執行緒的計算結果，計算出整個Excel的日均銀行流水，程式碼如下：

package com.dreyer.javadoc.thread;

import java.util.Map;
import java.util.concurrent.*;

/**
 * @description 銀行交易流水服務類
 * @author: 會跳舞的機器人
 * @date: 16/5/15 上午11:29
 */
public class BankWaterService implements Runnable {
    /**
     * 建立4個屏障,處理完之後,執行當前類的run方法
     */
    private CyclicBarrier cyclicBarrier = new CyclicBarrier(4, this);

    /**
     * 啟動4個執行緒
     */
    private Executor executor = Executors.newFixedThreadPool(4);

    /**
     * 儲存每個sheet計算出來的銀行交易流水結果
     */
    private ConcurrentHashMap<String, Integer> sheetBankWaterCount = new ConcurrentHashMap<String, Integer>();

    /**
     * 交易流水統計
     */
    private void count() {
        for (int i = 0; i < 4; i++) {
            executor.execute(new Runnable() {
                public void run() {
                    // 模擬計算當前sheet的銀行交易流水資料的業務處理
                    sheetBankWaterCount.put(Thread.currentThread().getName(), 1);

                    // 銀行交易流水計算完成後,插入一個屏障
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    /**
     * 彙總計算結果
     */
    public void run() {
        int result = 0;
        for (Map.Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()) {
            result += sheet.getValue();
        }
        // 設定計算結果,並輸出
        sheetBankWaterCount.put("result", result);
        System.out.println(result);

    }
    public static void main(String[] args) {
        BankWaterService service = new BankWaterService();
        service.count();
    }
}

3、控制併發執行緒數Semaphore

Semaphore被用於控制特定資源在同一個時間被訪問的執行緒數量，它通過協調各個執行緒，以保證資源可以被合理的使用。
做個比喻，把Semaphore比作是控制流量的紅綠燈，比如xx馬路要限制流量，只允許同時有一百輛車在馬路上行駛，其他的都必須在路口等待，所以前一百輛會看到綠燈，可以開進馬路，後面的車會看到紅燈，不能開進馬路，但是如果前面一百輛車中有5輛已經離開了馬路，那後面就允許有5輛車駛入馬路，這裡例子裡說的車就是執行緒，駛入馬路就代表執行緒正在執行，離開馬路就表示執行緒執行完成，看到紅燈就代表執行緒被阻塞，不能執行。

應用場景：Semaph可以用來做流量限制，特別是公共資源有限的應用場景，比如說資料庫連線。
假如有一個需求，要讀取幾萬個檔案的資料，因為都是IO密集型人物，我們可以啟動幾十個執行緒併發的讀取，但是如果讀取到記憶體後，還需要儲存到資料庫，而資料庫的連線數只有10個，這時候我們就必須控制只有10個執行緒同時獲取到資料庫連線，否則會丟擲異常提示無法連線資料庫。針對這種情況，我們就可以使用Semaphore來做流量控制。程式碼如下：

package com.dreyer.javadoc.thread;

import java.util.concurrent.*;

/**
 * @description
 * @author: 會跳舞的機器人
 * @date: 16/5/15 上午11:59
 */
public class SemaphoreDemo {
    /**
     * 執行緒數量
     */
    private static final int THREAD_COUNT = 30;

    /**
     * 執行緒池
     */
    private static ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

    private static Semaphore semaphore = new Semaphore(10);


    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.execute(new Runnable() {
                public void run() {
                    try {
                        // 獲取一個"許可證"
                        semaphore.acquire();

                        // 模擬資料儲存
                        TimeUnit.SECONDS.sleep(2);
                        System.out.println("save date...");

                        // 執行完後,歸還"許可證"
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        executor.shutdown();
    }
}

在程式碼中，雖然有30個執行緒在執行，但是隻執行10個併發的執行。所以我們可以看到在執行的過程中
save data...是每10個輸出的。

Semaphore的構造方法Semaphore(int permits)接受一個整形的數字，表示可用的許可證數量。
Semaphore(10)表示執行10個執行緒獲取許可證，也就是最大的併發數是10。
Semaphore的用法也很簡單，首先使用Semaphore.acquire()方法獲取一個許可證，使用完之後呼叫release()方法歸還許可證。

4、執行緒間交換資料的Exchanger

Exchanger（交換者）是一個用於執行緒間協作的工具類。Exchanger用於進行執行緒間的資料交換。它提供一個同步點，在這個同步點，兩個執行緒可以交換彼此的資料。這兩個執行緒通過exchange方法交換資料，如果第一個執行緒先執行exchange()方法，它會一直等待第二個執行緒也執行exchange方法，當兩個執行緒都到達同步點時，這兩個執行緒就可以交換資料，將本執行緒生產出來的資料傳遞給對方。

下面來看一下Exchanger的應用場景。

Exchanger可以用於遺傳演算法，遺傳演算法裡需要選出兩個人作為交配物件，這時候會交換兩人的資料，並使用交叉規則得出2個交配結果。Exchanger也可以用於校對工作，比如我們需要將紙製銀行流水通過人工的方式錄入成電子銀行流水，為了避免錯誤，採用AB崗兩人進行錄入，錄入到Excel之後，系統需要載入這兩個Excel，並對兩個Excel資料進行校對，看看是否
錄入一致，程式碼示例如下：

package main.java.com.robot.demo;

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

/**
 * @author: 會跳舞的機器人
 * @date: 2017/8/18 15:32
 * @description: 執行緒間交換資料的Exchanger示例
 */
public class ExchangerDemo {
    private static final Exchanger<String> exchanger = new Exchanger<>();
    /**
     * 執行緒數
     */
    private static ExecutorService executorService = Executors.newFixedThreadPool(2);

    public static void main(String[] args) {
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String a = "銀行流水A"; // A錄入的銀行流水資料
                    exchanger.exchange(a);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String b = "銀行流水B"; // B錄入的銀行流水資料
                    String a = exchanger.exchange(b);
                    System.out.println("A和B的資料是否一致：" + a.equals(b) + "；A錄入的是" + a + "；B錄入的是：" + b);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        executorService.shutdown();
    }
}

程式碼輸出：

A和B的資料是否一致：false；A錄入的是銀行流水A；B錄入的是：銀行流水B

如果把變數a、b的值改為一樣的，則會輸出

A和B的資料是否一致：true；A錄入的是銀行流水A；B錄入的是：銀行流水A

相關文章