在ArrayBlockingQueue與LinkedBlockingQueue一文中有提到過一個同步器框架：AbstractQueuedSynchronizer，簡稱AQS，今天我們來揭開它神祕的面紗。我們知道在ArrayBlockingQueue和LinkedeBlockQueue中，我們間接使用到了AQS，其實它的直接使用是對鎖的實現，例如：ReentrantLock、Semaphore、CountDownLatch等。在這裏，我們就會有幾點疑問了：
1、AQS和鎖有什麼關係？
2、AQS是怎麼實現和線程的交互的？
3、AQS是怎麼保證線程安全性的？
下面我們帶着這三個疑問，來開啓我們的AQS之旅吧！
首先，我們來看一下AQS的框架圖，這張圖摘自網絡，很容易說明它的體系：
通過這張圖，我們可以得知，有一個共享資源state，有一個CLH雙向鏈表的隊列，爲什麼叫CLH隊列，是由於這是由外國三個人做出來的，他們的名字開頭合起來叫CLH，所以以他們的名字命名的，隊列中有兩個指針，一個頭指針head，一個尾指針tail。在進行多個線程在搶佔同一個資源的時候，沒有獲得資源的線程會在一個 隊列中進行排隊等待，獲得資源的線程可以對state資源進行操作，就像我們讀書的時候去飯堂打飯，窗口只有一個，優先到達的肯定最先打飯，其他的就只能乖乖在後面排着，這個場景中窗口就是裏面的state共享資源，在AQS中，通過volatie關鍵字定義共享資源，包括state和Node隊列，關於volatie關鍵字，後面也會專門用博客來介紹一下，它可以保證線程之間的可見性，防止指定重排序，但是不能保證例如i++操作的原子性，如何保證state的原子性呢，通過unsafe中的CAS自旋來保證(compareAndSetState方法)，首先大家知道這點就可以了。
/**
* Head of the wait queue, lazily initialized. Except for
* initialization, it is modified only via method setHead. Note:
* If head exists, its waitStatus is guaranteed not to be
* CANCELLED.
*/
private transient volatile Node head;
/**
* Tail of the wait queue, lazily initialized. Modified only via
* method enq to add new wait node.
*/
private transient volatile Node tail;
/**
* The synchronization state.
*/
private volatile int state;
對於state的訪問方式，AQS裏面提供了三個方法，一個是獲取state的值，一個是給state賦值，還有一個就是通過CAS操作來設置state的值：
protected final int getState() {
return state;
}
protected final void setState(int newState) {
state = newState;
}
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
對於資源的訪問，AQS也提供了兩種方式，一種是獨佔(Exclusive)，表示同一時刻只能有一個線程執行，例如ReentrantLock，一個是共享(Share)，表示同一時刻可以有多個線程同時執行，例如Semaphore、CountDownLatch，也有可能是兩者都實現，例如ReentrantReadWriteLock，當然，我們也可以自定義同步器，自定義同步器繼承自AQS後只需要實現共享資源state的獲取和釋放即可，上面的ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock中都有相關的內部類實現了AQS中對於共享資源state的獲取和釋放，至於線程的等待隊列的維護，包括資源獲取失敗入隊，喚醒線程出隊等，也就是上圖中進入CLH隊列中的等待線程，AQS已經幫我們實現好了。
自定義同步器實現時主要實現以下幾種方法：
isHeldExclusively()：該線程是否正在獨佔資源。只有用到condition才需要去實現它。
tryAcquire(int)：獨佔方式。嘗試獲取資源，成功則返回true，失敗則返回false。
tryRelease(int)：獨佔方式。嘗試釋放資源，成功則返回true，失敗則返回false。
tryAcquireShared(int)：共享方式。嘗試獲取資源。負數表示失敗；0表示成功，但沒有剩餘可用資源；正數表示成功，且有剩餘資源。
tryReleaseShared(int)：共享方式。嘗試釋放資源，如果釋放後允許喚醒後續等待結點返回true，否則返回false。
查看AQS的源代碼，會發現上面的方法並沒有定義爲一個抽象方法，而是拋出了一個異常：
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
這是因爲Doug Lea在做這方面實現的時候，考慮到並不是所有的自定義同步器都需要實現上面每個方法，有的只需要實現其中兩個，例如tryAcquire和tryRelease，所以並不是強制性的，用戶自己去選擇吧。
用ReentrantLock來說，共享資源初始化爲state=0，當我們調用它的lock方法的時候，它底層實際上是會執行自己內部實現的tryAcquire方法，將自己變成獨佔鎖，並且讓state加1，其他線程在進行tryAcquire的時候就會失敗，當然在我們釋放鎖之前，我們還可以進行上鎖，實際上是將state進行累加，這就是ReentrantLock爲什麼是可重入鎖的原因，當然既然調用lock方法，那也應該調用釋放鎖的方法：unlock，當調用了它的unlock方法的時候，底層也實際上是會執行內部實現的tryRelease方法，將state減1，當state爲0的時候，表示該線程釋放掉了鎖，其他線程就有機會獲取到鎖了。
上面場景用圖示類說明，多個線程想要搶佔同一個資源：
例如線程3搶到了資源進行上鎖，並將state加1，其他的線程則在CLH隊列中等待着，並時刻關注state是不是等於0 ，也就是線程3釋放掉鎖了木有：
當線程3釋放掉鎖後，其他線程纔有可能再對共享資源上鎖：
下面我們來看一下AQS實現的源代碼。首先我們來開AQS中獨佔鎖acquire的實現：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
其中tryAcquire方法是AQS中定義讓用戶自己實現的方法，這個方法的作用就是嘗試去獲取共享資源，如果獲取成功，則直接返回。接下來我們看addWaiter方法，這個方法的作用就是將一個帶有獨佔鎖或共享鎖的Node節點強制放入到CLH隊尾，意思就是那些個獲取共享資源不成功的線程，強制你去排隊：
private Node addWaiter(Node mode) {
// 定義一個Node節點，其中mode有兩種：EXCLUSIVE(獨佔)和SHARED（共享）
Node node = new Node(Thread.currentThread(), mode);
// 嘗試用快速的方式將node放入隊尾
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 上面執行不成功，通過enq強制將node放入隊尾
enq(node);
return node;
}
我們再來看一下enq方法，這個方法就是通過CAS自旋操作，讓其無論如何都要加入到隊列中：
private Node enq(final Node node) {
for (;;) {//自旋操作，無論如何都要操作成功
Node t = tail;
if (t == null) { // 隊列爲空，則將Node節點設置爲頭結點
if (compareAndSetHead(new Node()))
tail = head;
} else {// 隊列不爲空，通過CAS自旋讓其放入尾部
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
當線程獲取共享資源失敗，並且加入到CLH隊列的尾部了，接下來的acquireQueued方法就是進入等待區休息了，然後等使用共享資源的線程釋放鎖喚醒自己，自己獲取到資源後再進行操作了
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;//這個標記用來表示自己是否拿到共享資源了
try {
boolean interrupted = false;//這個標記是等待過程是否被中斷過
for (;;) {
final Node p = node.predecessor();//拿到該節點的前驅節點
//如果前驅節點是head，表示自己在CLH隊列中處於優先獲取資源的節點，那麼就去嘗試競爭資源
//head節點釋放掉鎖，那麼就可以喚醒該節點了
if (p == head && tryAcquire(arg)) {
// 成功拿到資源，則讓head指向該節點
setHead(node);
// 拿到資源後，那麼我就去幹自己的事情了，此時也就出隊了
p.next = null; // help GC
failed = false;
//返回等待過程中是否被中斷過
return interrupted;
}
// 沒有拿到資源，那就自己休息休息吧，等待着被喚醒
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 等待的過程中被中斷的標記
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
其中shouldParkAfterFailedAcquire來檢查自己是否真的可以去休息了，比如它的前驅節點是隨隨便便站着隊排一下，那麼我就可以不用休息了，知道它找到前面都是正常等待的線程，那麼就調用parkAndCheckInterrupt這個方法安心的休息，真正進入等待狀態，此時處於waiting狀態的線程可以通過unpark或者被interrupt來喚醒，我們來看一下這個方法的大致流程：
1、結點進入隊尾後，檢查狀態，找到安全休息點；
2、調用park()進入waiting狀態，等待unpark()或interrupt()喚醒自己；
3、被喚醒後，看自己是不是有資格能拿到號。如果拿到，head指向當前結點，並返回從入隊到拿到號的整個過程中是否被中斷過；如果沒拿到，繼續流程1。流程圖如下：
acquire方法的總體流程圖如下：
看完了acquire方法的實現，接下來我們看release方法的實現，release方法是獨佔模式下線程釋放掉共享資源的入口，如果徹底釋放，將state設置爲0的時候，則其他線程就會從CLH隊列中被喚醒，然後獲取到共享資源，源代碼如下：
public final boolean release(int arg) {
//嘗試釋放資源
if (tryRelease(arg)) {
//獲取到頭結點
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);//喚醒等待隊列中的下一個線程
return true;
}
return false;
}
跟tryAcquire一樣，tryRelease方法也是由自定義同步容器實現，主要的操作就是將state-arg，直到它徹底釋放資源：state=0
unparkSuccessor方法主要是喚醒CLH等待隊列中的沒有放棄的處於正常等待的線程：
/**
* Wakes up node's successor, if one exists.
*
* @param node the node
*/
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
好了，AQS的acquire和release方法大致解析到這裏了，還有共享模式acquireShared和releaseShared，後面有時間再介紹，接下來我們看ReentrantLock是怎麼和AQS結合起來的，在ReentrantLock中定義了一個抽象的Sync，它繼承AQS，實現了裏面的tryAcquire和tryRelease方法：
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
abstract void lock();
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
}
它裏面提供了一個抽象的lock方法，用來實現公平鎖和非公平鎖的實現，我們分別來看一下他們的源代碼，公平鎖的實現：
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
非公平鎖的實現：
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
可以看到實現了AQS的ReentrantLock中，tryAcquire方法就是對共享資源state進行加的操作，tryRelease方法就是對state進行減的操作，所以我們在實現AQS的時候tryAcquire和tryRelease、tryAcquireShared和tryReleaseShared都是成對出現的，也就是我們在使用ReentrantLock的lock方法進行上鎖後，也應該代碼的finally塊使用unlock釋放掉鎖，否則會出現很多不可預知的問題，關於ReentrantLock，我們下篇博客見！！文中有些地方可能寫的不是很好，歡迎大家指正。