本文基於 jdk 1.8 。
CountDownLatch 的使用
前面的文章中說到了 volatile 以及用 volatile 來實現自旋鎖，例如 java.util.concurrent.atomic 包下的工具類。但是 volatile 的使用場景畢竟有限，很多的情況下並不是適用，這個時候就需要 synchronized 或者各種鎖實現了。今天就來說一下幾種鎖的實現原理。
先來看一個最簡單的 CountDownLatch 使用方法，例子很簡單，可以執行看一下效果。CountDownLatch 的作用是：當一個執行緒需要另外一個或多個執行緒完成後，再開始執行。比如主執行緒要等待一個子執行緒完成環境相關配置的載入工作，主執行緒才繼續執行，就可以利用 CountDownLatch 來實現。
例如下面這個例子，首先例項化一個 CountDownLatch ，引數可以理解為一個計數器，這裡為 1，然後主執行緒執行，呼叫 worker 子執行緒，接著呼叫 CountDownLatch 的 await() 方法，表示阻塞主執行緒。當子執行緒執行完成後，在 finnaly 塊呼叫 countDown() 方法，表示一個等待已經完成，把計數器減一，直到減為 0，主執行緒又開始執行。
private static CountDownLatch latch = new CountDownLatch(1);
public static void main(String[] args) throws InterruptedException{
System.out.println("主執行緒開始......");
Thread thread = new Thread(new Worker());
thread.start();
System.out.println("主執行緒等待......");
System.out.println(latch.toString());
latch.await();
System.out.println(latch.toString());
System.out.println("主執行緒繼續.......");
}
public static class Worker implements Runnable {
@Override
public void run() {
System.out.println("子執行緒任務正在執行");
try {
Thread.sleep(2000);
}catch (InterruptedException e){
}finally {
latch.countDown();
}
}
}執行結果如下：
主執行緒開始......
子執行緒任務正在執行
主執行緒等待......
java.util.concurrent.CountDownLatch@1d44bcfa[Count = 1]
java.util.concurrent.CountDownLatch@1d44bcfa[Count = 0]
主執行緒繼續.......AQS 的原理
這麼好用的功能是怎麼實現的呢，下面就來說一說實現它的核心技術原理 AQS。 AQS 全稱 AbstractQueuedSynchronizer，是 java.util.concurrent 中提供的一種高效且可擴充套件的同步機制。它可以用來實現可以依賴 int 狀態的同步器，獲取和釋放引數以及一個內部FIFO等待佇列，除了CountDownLatch，ReentrantLock、Semaphore 等功能實現都使用了它。
接下來用 CountDownLatch 來分析一下 AQS 的實現。建議看文章的時候先大致看一下原始碼，有助於理解下面所說的內容。
在我們的方法中呼叫 awit()和countDown()的時候，發生了幾個關鍵的呼叫關係，我畫了一個方法呼叫圖。
首先在 CountDownLatch 類內部定義了一個 Sync 內部類，這個內部類就是繼承自 AbstractQueuedSynchronizer 的。並且重寫了方法 tryAcquireShared和tryReleaseShared。例如當呼叫 awit()方法時，CountDownLatch 會呼叫內部類Sync 的 acquireSharedInterruptibly() 方法，然後在這個方法中會呼叫 tryAcquireShared 方法，這個方法就是 CountDownLatch 的內部類 Sync 裡重寫的 AbstractQueuedSynchronizer 的方法。呼叫 countDown() 方法同理。
這種方式是使用 AbstractQueuedSynchronizer 的標準化方式，大致分為兩步：
1、內部持有繼承自 AbstractQueuedSynchronizer 的物件 Sync；
2、並在 Sync 內重寫 AbstractQueuedSynchronizer protected 的部分或全部方法，這些方法包括如下幾個：
之所以要求子類重寫這些方法，是為了讓使用者（這裡的使用者指 CountDownLatch 等）可以在其中加入自己的判斷邏輯，例如 CountDownLatch 在 tryAcquireShared中加入了判斷，判斷 state 是否不為0，如果不為0，才符合呼叫條件。
tryAcquire和tryRelease是對應的，前者是獨佔模式獲取，後者是獨佔模式釋放。
tryAcquireShared和tryReleaseShared是對應的，前者是共享模式獲取，後者是共享模式釋放。
我們看到 CountDownLatch 重寫的方法 tryAcquireShared 實現如下：
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}判斷 state 值是否為0，為0 返回1，否則返回 -1。state 值是 AbstractQueuedSynchronizer 類中的一個 volatile 變數。
private volatile int state;在 CountDownLatch 中這個 state 值就是計數器，在呼叫 await 方法的時候，將值賦給 state 。
等待執行緒入隊
根據上面的邏輯，呼叫 await() 方法時，先去獲取 state 的值，當計數器不為0的時候，說明還有需要等待的執行緒在執行，則呼叫 doAcquireSharedInterruptibly 方法，進來執行的第一個動作就是嘗試加入等待佇列 ，即呼叫 addWaiter（）方法， 原始碼如下：
到這裡就走到了 AQS 的核心部分，AQS 用內部的一個 Node 類維護一個 CHL Node FIFO 佇列。將當前執行緒加入等待佇列，並通過 parkAndCheckInterrupt（）方法實現當前執行緒的阻塞。下面一大部分都是在說明 CHL 佇列的實現，裡面用 CAS 實現佇列出入不會發生阻塞。
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//加入等待佇列
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
// 進入 CAS 迴圈
try {
for (;;) {
//當一個節點(關聯一個執行緒)進入等待佇列後， 獲取此節點的 prev 節點
final Node p = node.predecessor();
// 如果獲取到的 prev 是 head，也就是佇列中第一個等待執行緒
if (p == head) {
// 再次嘗試申請 反應到 CountDownLatch 就是檢視是否還有執行緒需要等待(state是否為0)
int r = tryAcquireShared(arg);
// 如果 r >=0 說明 沒有執行緒需要等待了 state==0
if (r >= 0) {
//嘗試將第一個執行緒關聯的節點設定為 head
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
//經過自旋tryAcquireShared後，state還不為0，就會到這裡，第一次的時候，waitStatus是0，那麼node的waitStatus就會被置為SIGNAL，第二次再走到這裡，就會用LockSupport的park方法把當前執行緒阻塞住
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}我看看到上面先執行了 addWaiter() 方法，就是將當前執行緒加入等待佇列，原始碼如下：
/** Marker to indicate a node is waiting in shared mode */
static final Node SHARED = new Node();
/** Marker to indicate a node is waiting in exclusive mode */
static final Node EXCLUSIVE = null;
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// 嘗試快速入隊操作，因為大多數時候尾節點不為 null
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//如果尾節點為空(也就是佇列為空) 或者嘗試CAS入隊失敗(由於併發原因)，進入enq方法
enq(node);
return node;
}上面是向等待佇列中新增等待者（waiter）的方法。首先構造一個 Node 實體，引數為當前執行緒和一個mode，這個mode有兩種形式，一個是 SHARED ，一個是 EXCLUSIVE，請看上面的程式碼。然後執行下面的入隊操作 addWaiter，和 enq() 方法的 else 分支操作是一樣的，這裡的操作如果成功了，就不用再進到 enq() 方法的迴圈中去了，可以提高效能。如果沒有成功，再呼叫 enq() 方法。
private Node enq(final Node node) {
// 死迴圈+CAS保證所有節點都入隊
for (;;) {
Node t = tail;
// 如果佇列為空 設定一個空節點作為 head
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
//加入隊尾
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}說明：迴圈加 CAS 操作是實現樂觀鎖的標準方式，CAS 是為了實現原子操作而出現的，所謂的原子操作指操作執行期間，不會受其他執行緒的干擾。Java 實現的 CAS 是呼叫 unsafe 類提供的方法，底層是呼叫 c++ 方法，直接操作記憶體，在 cpu 層面加鎖，直接對記憶體進行操作。
上面是 AQS 等待佇列入隊方法，操作在無限迴圈中進行，如果入隊成功則返回新的隊尾節點，否則一直自旋，直到入隊成功。假設入隊的節點為 node ，上來直接進入迴圈，在迴圈中，先拿到尾節點。
1、if 分支，如果尾節點為 null，說明現在佇列中還沒有等待執行緒，則嘗試 CAS 操作將頭節點初始化，然後將尾節點也設定為頭節點，因為初始化的時候頭尾是同一個，這和 AQS 的設計實現有關， AQS 預設要有一個虛擬節點。此時，尾節點不在為空，迴圈繼續，進入 else 分支；
2、else 分支，如果尾節點不為 null， node.prev = t ，也就是將當前尾節點設定為待入隊節點的前置節點。然後又是利用 CAS 操作，將待入隊的節點設定為佇列的尾節點，如果 CAS 返回 false，表示未設定成功，繼續迴圈設定，直到設定成功，接著將之前的尾節點（也就是倒數第二個節點）的 next 屬性設定為當前尾節點，對應 t.next = node 語句，然後返回當前尾節點，退出迴圈。
setHeadAndPropagate 方法負責將自旋等待或被 LockSupport 阻塞的執行緒喚醒。
private void setHeadAndPropagate(Node node, int propagate) {
//備份現在的 head
Node h = head;
//搶到鎖的執行緒被喚醒 將這個節點設定為head
setHead(node)
// propagate 一般都會大於0 或者存在可被喚醒的執行緒
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
// 只有一個節點 或者是共享模式 釋放所有等待執行緒 各自嘗試搶佔鎖
if (s == null || s.isShared())
doReleaseShared();
}
}Node 物件中有一個屬性是 waitStatus ，它有四種狀態，分別是：
//執行緒已被 cancelled ，這種狀態的節點將會被忽略，並移出佇列
static final int CANCELLED = 1;
// 表示當前執行緒已被掛起，並且後繼節點可以嘗試搶佔鎖
static final int SIGNAL = -1;
//執行緒正在等待某些條件
static final int CONDITION = -2;
//共享模式下 無條件所有等待執行緒嘗試搶佔鎖
static final int PROPAGATE = -3;等待執行緒被喚醒
當執行 CountDownLatch 的 countDown（）方法，將計數器減一，也就是state減一，當減到0的時候，等待佇列中的執行緒被釋放。是呼叫 AQS 的 releaseShared 方法來實現的，下面程式碼中的方法是按順序呼叫的，摘到了一起，方便檢視：
// AQS類
public final boolean releaseShared(int arg) {
// arg 為固定值 1
// 如果計數器state 為0 返回true，前提是呼叫 countDown() 之前不能已經為0
if (tryReleaseShared(arg)) {
// 喚醒等待佇列的執行緒
doReleaseShared();
return true;
}
return false;
}
// CountDownLatch 重寫的方法
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
// 依然是迴圈+CAS配合 實現計數器減1
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
/// AQS類
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
// 如果節點狀態為SIGNAL，則他的next節點也可以嘗試被喚醒
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
// 將節點狀態設定為PROPAGATE，表示要向下傳播，依次喚醒
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}因為這是共享型的，當計數器為 0 後，會喚醒等待佇列裡的所有執行緒，所有呼叫了 await() 方法的執行緒都被喚醒，併發執行。這種情況對應到的場景是，有多個執行緒需要等待一些動作完成，比如一個執行緒完成初始化動作，其他5個執行緒都需要用到初始化的結果，那麼在初始化執行緒呼叫 countDown 之前，其他5個執行緒都處在等待狀態。一旦初始化執行緒呼叫了 countDown ，其他5個執行緒都被喚醒，開始執行。
總結
1、AQS 分為獨佔模式和共享模式，CountDownLatch 使用了它的共享模式。
2、AQS 當第一個等待執行緒（被包裝為 Node）要入隊的時候，要保證存在一個 head 節點，這個 head 節點不關聯執行緒，也就是一個虛節點。
3、當佇列中的等待節點（關聯執行緒的，非 head 節點）搶到鎖，將這個節點設定為 head 節點。
4、第一次自旋搶鎖失敗後，waitStatus 會被設定為 -1（SIGNAL），第二次再失敗，就會被 LockSupport 阻塞掛起。
5、如果一個節點的前置節點為 SIGNAL 狀態，則這個節點可以嘗試搶佔鎖。
不妨到我的公眾號裡互動一下 :古時的風箏
