1 引言
在實際開發中，經常遇到這樣一種場景：有一組線程，每個線程去持行自己的任務，現在想實現等所有線程都持行完畢後，再向下執行代碼。比如我們開啓一組線程去同步服務器的數據，點贊記錄，下載記錄，收藏記錄等等用戶信息，所有數據同步完成之後繼續向下執行。
2 CountDownLatch的概念
CountDownLatch是一個同步工具類，用來協調多個線程之間的同步，用於開啓一組線程，使一個線程在等待這組線程完成各自工作之後，再繼續執行。CountDownLatch內部基於一個計數器實現。計數器初始值大於等於線程的數量（因爲每個線程至少執行countDown()方法一次）。當每一個線程完成自己任務後，計數器的值就會減一。當計數器的值爲0時，表示所有的線程都已經完成指定的任務，然後在CountDownLatch上等待的線程就可以繼續執行接下來的任務。
3 CountDownLatch的方法
CountDownLatch的主要方法包括：
//調用await()方法的線程會被掛起，它會等待直到count值爲0才繼續執行
public void await() throws InterruptedException { };
//和await()類似，只不過等待一定的時間後count值還沒變爲0的話就會繼續執行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };
//將count值減1
public void countDown() { };
4 CountDownLatch的示例
假設現在有這樣的場景：兩個閱卷老師同時對兩個班級的學生進行評分，最後需要統計出兩個班級所有學生的最高分和最低分。這裏可以利用CountDownLatch的思想，啓動兩個線程分別對兩個班級分數進行排序，在兩個班級都排好序之後，再綜合比較得出最大值和最小值。（當然這種場景啓動兩個線程消耗更大，效率較低。實際上可以通過插入排序、快速排序實現，本例方案的合理性不做討論，只是爲了演示CountDownLatch的用法）。
附實現代碼：
/**
* @author Carson Chu, [email protected]
* @date 2020/4/5 12:41
* @description
*/
public class Main {
public static void main(String[] args) {
int[] score0 = {2, 6, 7, 9, 3};
int[] score1 = {8, 6, 7, 1, 5};
/* 初始化CountDownLatch，包含兩個計數器 */
CountDownLatch countDownLatch = new CountDownLatch(2);
ExecutorService executorService0 = Executors.newCachedThreadPool();
/* 線程1對第一個數組進行排序 */
executorService0.submit(() -> {
Arrays.sort(score0);
/* 執行完計數器減1 */
countDownLatch.countDown();
});
ExecutorService executorService1 = Executors.newCachedThreadPool();
/* 線程2對第二個數組進行排序 */
executorService1.submit(() -> {
Arrays.sort(score1);
/* 執行完計數器減1 */
countDownLatch.countDown();
});
try {
/* 阻塞當前線程--main線程 */
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
int maxRes = score0[4] > score1[4] ? score0[4] : score1[4];
int minRes = score0[0] < score1[0] ? score0[0] : score1[0];
System.out.println("The maximum score is " + maxRes);
System.out.println("The minimum score is " + minRes);
}
}
5 CountDownLatch源碼分析
CountDownLatch底層是基於AbstractQueuedSynchronizer(即大名鼎鼎的AQS)實現的，AQS主要有兩種模式：共享模式(SHARED)和互斥模式(EXCLUSIVE)，CountDownLatch是基於共享模式的,內部封裝了一個繼承自AQS的類Sync，附源碼：
程序清單5-1 Sync源碼
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
/* 調用await()方法的底層實現 */
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
/* 調用countDown()方法的底層實現 */
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
每次調用await()方法時候，會利用上述代碼裏的tryAcquireShared()獲取當前計數器數量，如果不爲0，則執行如下代碼,這段代碼是幹嘛的呢，就是把所有等待的線程放入一個CLH隊列中。
程序清單5-2 await()方法核心實現
/**
* Acquires in shared interruptible mode.
* @param arg the acquire argument
*/
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
每次調用countDown()方法時候，會利用程序清單5-1代碼裏的tryReleaseShared()來判斷當前計數器是否爲0，如果爲0則直接返回，如果不爲0，則計數器減1，當計數器被減到0的時候，返回true，繼續執行如下代碼以喚醒線程（喚醒操作是基於LockSupport.unpark()實現的）。
關於LockSupport的機制及原理可參考我的另一篇博客，附傳送門↓：
Java併發編程（二）：LockSupport應用及原理分析
程序清單5-3 countDown()方法核心實現
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
//喚醒h線程
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
6 小結
要實現線程同步，除了CountDownLatch外，Java還提供了了一種內存屏障的機制CyclicBarrier，兩者的區別在於：
CountDownLatch是一個計數器，線程完成一個記錄一個，計數器遞減，只能用一次CyclicBarrier的計數器更像一個閥門，需要所有線程都到達，然後繼續執行，計數器遞增，提供reset功能，支持重置多次使用。