詳解CountDownLatch

CountDownLatch是什麼？ 

jdk1.5開始concurrent包裡提供的，併發程式設計工具類。 

CountDownLatch這個類能夠使一個執行緒等待其他執行緒完成各自的工作後再執行。CountDownLatch允許一個或多個執行緒等待其他執行緒完成操作。 

例如，應用程式的主執行緒希望在負責啟動框架服務的執行緒已經啟動所有的框架服務之後再執行。

CountDownLatch非常適合於對任務進行拆分，使其並行執行，比如某個任務執行2s，其對資料的請求可以分為五個部分，那麼就可以將這個任務拆分為5個子任務，分別交由五個執行緒執行，執行完成之後再由主執行緒進行彙總，此時，總的執行時間將決定於執行最慢的任務，平均來看，還是大大減少了總的執行時間。

CountDownLatch是不能複用的，不可能重新初始化或者修改CountDownLatch物件的內部計數器的值。

CountDownLatch如何工作？

CountDownLatch底層原理

public void countDown() {
  sync.releaseShared(1);
}複製程式碼

private static final class Sync extends AbstractQueuedSynchronizer {
  private static final long serialVersionUID = 4982264981922014374L;

  Sync(int count) {
    setState(count);
  }

  int getCount() {
    return getState();
  }

  protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
  }

  protected boolean tryReleaseShared(int releases) {
    for (;;) {
      int c = getState();   // 獲取當前state屬性的值
      if (c == 0)   // 如果state為0，則說明當前計數器已經計數完成，直接返回
        return false;
      int nextc = c-1;
      if (compareAndSetState(c, nextc)) // 使用CAS演算法對state進行設定
        return nextc == 0;  // 設定成功後返回當前是否為最後一個設定state的執行緒
    }
  }
}複製程式碼

public final boolean releaseShared(int arg) {
  if (tryReleaseShared(arg)) {
    doReleaseShared();
    return true;
  }
  return false;
}複製程式碼

private void doReleaseShared() {
  for (;;) {
    Node h = head;  // 記錄等待佇列中的頭結點的執行緒
    if (h != null && h != tail) {   // 頭結點不為空，且頭結點不等於尾節點
      int ws = h.waitStatus;
      if (ws == Node.SIGNAL) {  // SIGNAL狀態表示當前節點正在等待被喚醒
        if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))    // 清除當前節點的等待狀態
          continue;
        unparkSuccessor(h); // 喚醒當前節點的下一個節點
      } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
        continue;
    }
    if (h == head)  // 如果h還是指向頭結點，說明前面這段程式碼執行過程中沒有其他執行緒對頭結點進行過處理
      break;
  }
}複製程式碼

private void unparkSuccessor(Node node) {
  int ws = node.waitStatus;
  if (ws < 0)
    compareAndSetWaitStatus(node, ws, 0);   // 清除當前節點的等待狀態

  Node s = node.next;
  if (s == null || s.waitStatus > 0) {  // s的等待狀態大於0說明該節點中的執行緒已經被外部取消等待了
    s = null;
    // 從佇列尾部往前遍歷，找到最後一個處於等待狀態的節點，用s記錄下來
    for (Node t = tail; t != null && t != node; t = t.prev)
      if (t.waitStatus <= 0)
        s = t;
  }
  if (s != null)
    LockSupport.unpark(s.thread);   // 喚醒離傳入節點最近的處於等待狀態的節點執行緒
}複製程式碼

public void await() throws InterruptedException {
  sync.acquireSharedInterruptibly(1);
}
複製程式碼

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
  if (Thread.interrupted())
    throw new InterruptedException();
  if (tryAcquireShared(arg) < 0)
    doAcquireSharedInterruptibly(arg);
}複製程式碼

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) {   // 大於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);
  }
}複製程式碼

private void setHeadAndPropagate(Node node, int propagate) {
  Node h = head;
  setHead(node);    // 將當前節點設定為頭節點
  // 檢查喚醒過程是否需要往下傳遞，並且檢查頭結點的等待狀態
  if (propagate > 0 || h == null || h.waitStatus < 0 ||
      (h = head) == null || h.waitStatus < 0) {
    Node s = node.next;
    if (s == null || s.isShared())  // 如果下一個節點是嘗試以共享狀態獲取獲取執行許可權的節點，則將其喚醒
      doReleaseShared();
  }
}複製程式碼

CountDownLatch的demo

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複製程式碼

總結

CountDownLatch的作用就是允許一個或多個執行緒等待其他執行緒完成操作，看起來有點類似join() 方法，但其提供了比 join() 更加靈活的API。CountDownLatch可以手動控制在n個執行緒裡呼叫n次countDown方法使計數器進行減一操作，也可以在一個執行緒裡呼叫n次執行減一操作。而 join() 的實現原理是不停檢查join執行緒是否存活，如果 join 執行緒存活則讓當前執行緒永遠等待。所以兩者之間相對來說還是CountDownLatch使用起來較為靈活。

參考自：《Java併發程式設計的藝術》和www.jianshu.com/p/128476015…