CountDownLatch、CyclicBarrier和Semaphore

一.CountDownLatch用法

CountDownLatch類位於java.util.concurrent包下，利用它能夠實現相似計數器的功能。好比有一個任務A，它要等待其餘4個任務執行完畢以後才能執行，此時就能夠利用CountDownLatch來實現這種功能了。

CountDownLatch的構造函數接收一個int類型的參數做爲計數器，若是你想等待N個點完成，這裏就傳入N。

當咱們調用一次CountDownLatch的countDown方法時，N就會減1，CountDownLatch的await會阻塞當前線程，直到N變成零。因爲countDown方法能夠用在任何地方，因此這裏說的N個點，能夠是N個線程，也能夠是1個線程裏的N個執行步驟。用在多個線程時，你只須要把這個CountDownLatch的引用傳遞到線程裏。

其餘方法

若是有某個解析sheet的線程處理的比較慢，咱們不可能讓主線程一直等待，因此咱們可使用另一個帶指定時間的await方法，await(long time, TimeUnit unit): 這個方法等待特定時間後，就會再也不阻塞當前線程。join也有相似的方法。

注意：計數器必須大於等於0，只是等於0時候，計數器就是零，調用await方法時不會阻塞當前線程。CountDownLatch不可能從新初始化或者修改CountDownLatch對象的內部計數器的值。

public class CountDownLatchTest {
    private AtomicInteger atomicInteger = new AtomicInteger();

    @Test
    public void cuntDownLatchTest() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        executorService.execute(() -> {
            atomicInteger.addAndGet(1000);
            countDownLatch.countDown();
        });
        executorService.execute(() -> {
            atomicInteger.addAndGet(1000);
            countDownLatch.countDown();
        });
        executorService.execute(() -> {
            atomicInteger.addAndGet(1000);
            countDownLatch.countDown();
        });
        System.out.println("等待子線程執行");
        countDownLatch.await();
        System.out.println("子線程執行完畢");
        System.out.println(atomicInteger);

    }
}

 執行結果

等待子線程執行
子線程執行完畢
3000

二.CyclicBarrier用法

CyclicBarrier 的字面意思是可循環使用（Cyclic）的屏障（Barrier）。它要作的事情是，讓一組線程到達一個屏障（也能夠叫同步點）時被阻塞，直到最後一個線程到達屏障時，屏障纔會開門，全部被屏障攔截的線程纔會繼續幹活。CyclicBarrier默認的構造方法是CyclicBarrier(int parties)，其參數表示屏障攔截的線程數量，每一個線程調用await方法告訴CyclicBarrier我已經到達了屏障，而後當前線程被阻塞。

public class CyclicBarrierTest {
    private static final int THREAD_NUMBER = 3;
    private static CyclicBarrier sCyclicBarrier = new CyclicBarrier(
            THREAD_NUMBER, new Runnable() {
        @Override
        public void run() {
            System.out.println("你們都到達了宿舍樓下，一塊兒出發吧。。。");
        }
    });

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_NUMBER);
        for (int i = 0; i < THREAD_NUMBER; i++) {
            executorService.execute(new WalkFromDomitoryToCanteenRunnable(sCyclicBarrier, "同窗" + i));
        }
        try {
            Thread.sleep(10000);//主線程睡眠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("CyclicBarrier重用");
        for (int i = THREAD_NUMBER; i < THREAD_NUMBER * 2; i++) {
            executorService.execute(new WalkFromDomitoryToCanteenRunnable(sCyclicBarrier, "同窗" + i));
        }
    }

    /**
     * 從宿舍到食堂線程
     *
     * @author LiuYi
     */
    public static class WalkFromDomitoryToCanteenRunnable implements Runnable {
        private CyclicBarrier mCyclicBarrier;
        private String mName;

        public WalkFromDomitoryToCanteenRunnable(CyclicBarrier cyclicBarrier,
                                                 String name) {
            this.mCyclicBarrier = cyclicBarrier;
            this.mName = name;
        }

        @Override
        public void run() {
            System.out.println(mName + "開始從宿舍出發。。。");
            try {
                Thread.sleep(1000);
                mCyclicBarrier.await();// 等待別同窗
                // 前往食堂
                System.out.println(mName + "開始從宿舍樓下出發。。。");
                Thread.sleep(1000);
                System.out.println(mName + "達到食堂。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}

 執行結果

同窗0開始從宿舍出發。。。
同窗2開始從宿舍出發。。。
同窗1開始從宿舍出發。。。
你們都到達了宿舍樓下，一塊兒出發吧。。。
同窗0開始從宿舍樓下出發。。。
同窗2開始從宿舍樓下出發。。。
同窗1開始從宿舍樓下出發。。。
同窗0達到食堂。。。
同窗2達到食堂。。。
同窗1達到食堂。。。
CyclicBarrier重用
同窗3開始從宿舍出發。。。
同窗4開始從宿舍出發。。。
同窗5開始從宿舍出發。。。
你們都到達了宿舍樓下，一塊兒出發吧。。。
同窗3開始從宿舍樓下出發。。。
同窗4開始從宿舍樓下出發。。。
同窗5開始從宿舍樓下出發。。。
同窗4達到食堂。。。
同窗5達到食堂。。。
同窗3達到食堂。。。

 

CyclicBarrier的應用場景

CyclicBarrier能夠用於多線程計算數據，最後合併計算結果的應用場景。好比咱們用一個Excel保存了用戶全部銀行流水，每一個Sheet保存一個賬戶近一年的每筆銀行流水，如今須要統計用戶的日均銀行流水，先用多線程處理每一個sheet裏的銀行流水，都執行完以後，獲得每一個sheet的日均銀行流水，最後，再用barrierAction用這些線程的計算結果，計算出整個Excel的日均銀行流水。

CyclicBarrier和CountDownLatch的區別

• CountDownLatch的計數器只能使用一次。而CyclicBarrier的計數器可使用reset() 方法重置。因此CyclicBarrier能處理更爲複雜的業務場景，好比若是計算髮生錯誤，能夠重置計數器，並讓線程們從新執行一次。
• CyclicBarrier還提供其餘有用的方法，好比getNumberWaiting方法能夠得到CyclicBarrier阻塞的線程數量。isBroken方法用來知道阻塞的線程是否被中斷。好比如下代碼執行完以後會返回true。

三.Semaphore用法

　　Semaphore翻譯成字面意思爲 信號量，Semaphore能夠控同時訪問的線程個數，經過 acquire() 獲取一個許可，若是沒有就等待，而 release() 釋放一個許可。

　　Semaphore類位於java.util.concurrent包下，它提供了2個構造器：

public Semaphore(int permits) {          //參數permits表示許可數目，即同時能夠容許多少線程進行訪問
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //這個多了一個參數fair表示是不是公平的，即等待時間越久的越先獲取許可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

 倘若一個工廠有5臺機器，可是有8個工人，一臺機器同時只能被一個工人使用，只有使用完了，其餘工人才能繼續使用。那麼咱們就能夠經過Semaphore來實現：

public class Test {
    public static void main(String[] args) {
        int N = 8;            //工人數
        Semaphore semaphore = new Semaphore(5); //機器數目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }
     
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }
         
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"佔用一個機器在生產...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"釋放出機器");
                semaphore.release();           
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 執行結果

工人0佔用一個機器在生產...
工人1佔用一個機器在生產...
工人2佔用一個機器在生產...
工人4佔用一個機器在生產...
工人5佔用一個機器在生產...
工人0釋放出機器
工人2釋放出機器
工人3佔用一個機器在生產...
工人7佔用一個機器在生產...
工人4釋放出機器
工人5釋放出機器
工人1釋放出機器
工人6佔用一個機器在生產...
工人3釋放出機器
工人7釋放出機器
工人6釋放出機器