java.util.concurrent（J.U.C）大大提高了併發效能。

AQS 被認為是 J.U.C 的核心。

什麼是AQS？

 AQS是AbstractQueuedSynchronizer的簡稱。AQS提供了一種實現阻塞鎖和一系列依賴FIFO等待佇列的同步器的框架。

CountdownLatch

什麼是CountdownLatch

用來控制一個執行緒等待多個執行緒。

維護了一個計數器 cnt，每次呼叫 countDown() 方法會讓計數器的值減 1，減到 0 的時候，那些因為呼叫 await() 方法而在等待的執行緒就會被喚醒。

public class CountdownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        final int totalThread = 10;
        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(() -> {
                System.out.print("run..");
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        System.out.println("end");
        executorService.shutdown();
    }
}
 

run..run..run..run..run..run..run..run..run..run..end

CyclicBarrier

用來控制多個執行緒互相等待，只有當多個執行緒都到達時，這些執行緒才會繼續執行。

和 CountdownLatch 相似，都是通過維護計數器來實現的。執行緒執行 await() 方法之後計數器會減 1，並進行等待，直到計數器為 0，所有呼叫 await() 方法而在等待的執行緒才能繼續執行。

CyclicBarrier 和 CountdownLatch 的一個區別是，CyclicBarrier 的計數器通過呼叫 reset() 方法可以迴圈使用，所以它才叫做迴圈屏障。

CyclicBarrier 有兩個建構函式，其中 parties 指示計數器的初始值，barrierAction 在所有執行緒都到達屏障的時候會執行一次。

public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}

public CyclicBarrier(int parties) {
    this(parties, null);
}

public class CyclicBarrierExample {

    public static void main(String[] args) {
        final int totalThread = 10;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(() -> {
                System.out.print("before..");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.print("after..");
            });
        }
        executorService.shutdown();
    }
}

before..before..before..before..before..before..before..before..before..before..after..after..after..after..after..after..after..after..after..after..

Semaphore

Semaphore 類似於作業系統中的訊號量，可以控制對互斥資源的訪問執行緒數。

以下程式碼模擬了對某個服務的併發請求，每次只能有 3 個客戶端同時訪問，請求總數為 10。

public class SemaphoreExample {

    public static void main(String[] args) {
        final int clientCount = 3;
        final int totalRequestCount = 10;
        Semaphore semaphore = new Semaphore(clientCount);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalRequestCount; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    System.out.print(semaphore.availablePermits() + " ");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }
        executorService.shutdown();
    }
}