歡迎關注掘金：【Ccww】，一起學習
提升能力，漲薪可待
面試知識，工作可待
實戰演練，拒絕996
也歡迎關注微信公眾號【Ccww筆記】，原創技術文章第一時間推出
如果此文對你有幫助、喜歡的話，那就點個讚唄！
前言
是不是感覺在工作上難於晉升了呢？
是不是感覺找工作面試是那麼難呢？
是不是感覺自己每天都在996加班呢？
在工作上必須保持學習的能力，這樣才能在工作得到更好的晉升，漲薪指日可待，歡迎一起學習【提升能力，漲薪可待】系列
在找工作面試應在學習的基礎進行總結面試知識點，工作也指日可待，歡迎一起學習【面試知識，工作可待】系列
最後，理論知識到準備充足，是不是該躬行起來呢？歡迎一起學習【實戰演練，拒絕996】系列
一、AQS是什麼？有什麼用？
AQS全稱AbstractQueuedSynchronizer，即抽象的佇列同步器，是一種用來構建鎖和同步器的框架。
基於AQS構建同步器：
- ReentrantLock
- Semaphore
- CountDownLatch
- ReentrantReadWriteLock
- SynchronusQueue
- FutureTask
優勢：
- AQS 解決了在實現同步器時涉及的大量細節問題，例如自定義標準同步狀態、FIFO 同步佇列。
- 基於 AQS 來構建同步器可以帶來很多好處。它不僅能夠極大地減少實現工作，而且也不必處理在多個位置上發生的競爭問題。
二、AQS核心知識
2.1 AQS核心思想
如果被請求的共享資源空閒，則將當前請求資源的執行緒設定為有效的工作執行緒，並且將共享資源設定為鎖定狀態。如果被請求的共享資源被佔用，那麼就需要一套執行緒阻塞等待以及被喚醒時鎖分配的機制，這個機制AQS是用CLH佇列鎖實現的，即將暫時獲取不到鎖的執行緒加入到佇列中。如圖所示：
Sync queue： 同步佇列，是一個雙向列表。包括head節點和tail節點。head節點主要用作後續的排程。
2.2 AQS設計思想
- AQS使用一個int成員變數來表示同步狀態
- 使用Node實現FIFO佇列，可以用於構建鎖或者其他同步裝置
- AQS資源共享方式：獨佔Exclusive（排它鎖模式）和共享Share（共享鎖模式）
AQS它的所有子類中，要麼實現並使用了它的獨佔功能的api，要麼使用了共享鎖的功能，而不會同時使用兩套api，即便是最有名的子類ReentrantReadWriteLock也是通過兩個內部類讀鎖和寫鎖分別實現了兩套api來實現的
2.3 state狀態
state狀態使用volatile int型別的變數，表示當前同步狀態。state的訪問方式有三種:
- getState()
- setState()
- compareAndSetState()
2.4 AQS中Node常量含義
CANCELLED
waitStatus值為1時表示該執行緒節點已釋放（超時、中斷），已取消的節點不會再阻塞。
SIGNAL
waitStatus為-1時表示該執行緒的後續執行緒需要阻塞，即只要前置節點釋放鎖，就會通知標識為 SIGNAL 狀態的後續節點的執行緒
CONDITION
waitStatus為-2時，表示該執行緒在condition佇列中阻塞（Condition有使用）
PROPAGATE
waitStatus為-3時，表示該執行緒以及後續執行緒進行無條件傳播（CountDownLatch中有使用）共享模式下， PROPAGATE 狀態的執行緒處於可執行狀態
2.5 同步佇列為什麼稱為FIFO呢？
因為只有前驅節點是head節點的節點才能被首先喚醒去進行同步狀態的獲取。當該節點獲取到同步狀態時，它會清除自己的值，將自己作為head節點，以便喚醒下一個節點。
2.6 Condition佇列
除了同步佇列之外，AQS中還存在Condition佇列，這是一個單向佇列。呼叫ConditionObject.await()方法，能夠將當前執行緒封裝成Node加入到Condition佇列的末尾，然後將獲取的同步狀態釋放（即修改同步狀態的值，喚醒在同步佇列中的執行緒）。
Condition佇列也是FIFO。呼叫ConditionObject.signal()方法，能夠喚醒firstWaiter節點，將其新增到同步佇列末尾。
2.7 自定義同步器的實現
在構建自定義同步器時，只需要依賴AQS底層再實現共享資源state的獲取與釋放操作即可。自定義同步器實現時主要實現以下幾種方法：
- isHeldExclusively()：該執行緒是否正在獨佔資源。只有用到condition才需要去實現它。
- tryAcquire(int)：獨佔方式。嘗試獲取資源，成功則返回true，失敗則返回false。
- tryRelease(int)：獨佔方式。嘗試釋放資源，成功則返回true，失敗則返回false。
- tryAcquireShared(int)：共享方式。嘗試獲取資源。負數表示失敗；0表示成功，但沒有剩餘可用資源；正數表示成功，且有剩餘資源。
- tryReleaseShared(int)：共享方式。嘗試釋放資源，如果釋放後允許喚醒後續等待結點返回true，否則返回false。
三 AQS實現細節
執行緒首先嚐試獲取鎖，如果失敗就將當前執行緒及等待狀態等資訊包裝成一個node節點加入到FIFO佇列中。 接著會不斷的迴圈嘗試獲取鎖，條件是當前節點為head的直接後繼才會嘗試。如果失敗就會阻塞自己直到自己被喚醒。而當持有鎖的執行緒釋放鎖的時候，會喚醒佇列中的後繼執行緒。
3.1 獨佔模式下的AQS
所謂獨佔模式，即只允許一個執行緒獲取同步狀態，當這個執行緒還沒有釋放同步狀態時，其他執行緒是獲取不了的，只能加入到同步佇列，進行等待。
很明顯，我們可以將state的初始值設為0，表示空閒。當一個執行緒獲取到同步狀態時，利用CAS操作讓state加1，表示非空閒，那麼其他執行緒就只能等待了。釋放同步狀態時，不需要CAS操作，因為獨佔模式下只有一個執行緒能獲取到同步狀態。ReentrantLock、CyclicBarrier正是基於此設計的。
例如，ReentrantLock，state初始化為0，表示未鎖定狀態。A執行緒lock()時，會呼叫tryAcquire()獨佔該鎖並將state+1。
3.1.1 獨佔模式獲取資源-acquire方法
acquire以獨佔exclusive方式獲取資源。如果獲取到資源，執行緒直接返回，否則進入等待佇列，直到獲取到資源為止，且整個過程忽略中斷的影響。原始碼如下：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
複製程式碼流程圖：
- 呼叫自定義同步器的
tryAcquire()嘗試直接去獲取資源，如果成功則直接返回； - 沒成功，則
addWaiter()將該執行緒加入等待佇列的尾部，並標記為獨佔模式； acquireQueued()使執行緒在等待佇列中休息，有機會時（輪到自己，會被unpark()）會去嘗試獲取資源。獲取到資源後才返回。如果在整個等待過程中被中斷過，則返回true，否則返回false。- 如果執行緒在等待過程中被中斷過，它是不響應的。只是獲取資源後才再進行自我中斷
selfInterrupt()，將中斷補上。
3.1.2 獨佔模式獲取資源-tryAcquire方法
tryAcquire嘗試以獨佔的方式獲取資源，如果獲取成功，則直接返回true，否則直接返回false，且具體實現由自定義AQS的同步器實現的。
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
複製程式碼3.1.3 獨佔模式獲取資源-addWaiter方法
根據不同模式(Node.EXCLUSIVE互斥模式、Node.SHARED共享模式)建立結點並以CAS的方式將當前執行緒節點加入到不為空的等待佇列的末尾(通過compareAndSetTail()方法)。如果佇列為空，通過enq(node)方法初始化一個等待佇列，並返回當前節點。
/**
* 引數
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* 返回值
* @return the new node
*/
private Node addWaiter(Node mode) {
//將當前執行緒以指定的模式建立節點node
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
// 獲取當前同佇列的尾節點
Node pred = tail;
//佇列不為空，將新的node加入等待佇列中
if (pred != null) {
node.prev = pred;
//CAS方式將當前節點尾插入佇列中
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//當佇列為empty或者CAS失敗時會呼叫enq方法處理
enq(node);
return node;
}
複製程式碼其中，佇列為empty，使用enq(node)處理，將當前節點插入等待佇列，如果佇列為空，則初始化當前佇列。所有操作都是CAS自旋的方式進行，直到成功加入隊尾為止。
private Node enq(final Node node) {
//不斷自旋
for (;;) {
Node t = tail;
//當前佇列為empty
if (t == null) { // Must initialize
//完成佇列初始化操作，頭結點中不放資料，只是作為起始標記，lazy-load，在第一次用的時候new
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
//不斷將當前節點使用CAS尾插入佇列中直到成功為止
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
複製程式碼3.1.4 獨佔模式獲取資源-acquireQueued方法
acquireQueued用於已在佇列中的執行緒以獨佔且不間斷模式獲取state狀態，直到獲取鎖後返回。主要流程：
-
結點node進入佇列尾部後，檢查狀態；
-
呼叫park()進入waiting狀態，等待unpark()或interrupt()喚醒；
-
被喚醒後，是否獲取到鎖。如果獲取到，head指向當前結點，並返回從入隊到獲取鎖的整個過程中是否被中斷過；如果沒獲取到，繼續流程1
final boolean acquireQueued(final Node node, int arg) { //是否已獲取鎖的標誌，預設為true 即為尚未 boolean failed = true; try { //等待中是否被中斷過的標記 boolean interrupted = false; for (;;) { //獲取前節點 final Node p = node.predecessor(); //如果當前節點已經成為頭結點，嘗試獲取鎖（tryAcquire）成功，然後返回 if (p == head && tryAcquire(arg)) { setHead(node); p.next = null; // help GC failed = false; return interrupted; } //shouldParkAfterFailedAcquire根據對當前節點的前一個節點的狀態進行判斷，對當前節點做出不同的操作 //parkAndCheckInterrupt讓執行緒進入等待狀態，並檢查當前執行緒是否被可以被中斷 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { //將當前節點設定為取消狀態；取消狀態設定為1 if (failed) cancelAcquire(node); } } 複製程式碼
3.1.5 獨佔模式釋放資源-release方法
release方法是獨佔exclusive模式下執行緒釋放共享資源的鎖。它會呼叫tryRelease()釋放同步資源，如果全部釋放了同步狀態為空閒（即state=0）,當同步狀態為空閒時，它會喚醒等待佇列裡的其他執行緒來獲取資源。這也正是unlock()的語義，當然不僅僅只限於unlock().
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
複製程式碼3.1.6 獨佔模式釋放資源-tryRelease方法
tryRelease()跟tryAcquire()一樣實現都是由自定義定時器以獨佔exclusive模式實現的。因為其是獨佔模式，不需要考慮執行緒安全的問題去釋放共享資源，直接減掉相應量的資源即可(state-=arg)。而且tryRelease()的返回值代表著該執行緒是否已經完成資源的釋放，因此在自定義同步器的tryRelease()時，需要明確這條件，當已經徹底釋放資源(state=0)，要返回true，否則返回false。
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
複製程式碼ReentrantReadWriteLock的實現：
protected final boolean tryRelease(int releases) {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
//減掉相應量的資源(state-=arg)
int nextc = getState() - releases;
//是否完全釋放資源
boolean free = exclusiveCount(nextc) == 0;
if (free)
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}
複製程式碼3.1.7 獨佔模式釋放資源-unparkSuccessor
unparkSuccessor用unpark()喚醒等待佇列中最前驅的那個未放棄執行緒，此執行緒並不一定是當前節點的next節點，而是下一個可以用來喚醒的執行緒，如果這個節點存在，呼叫unpark()方法喚醒。
private void unparkSuccessor(Node node) {
//當前執行緒所在的結點node
int ws = node.waitStatus;
//置零當前執行緒所在的結點狀態，允許失敗
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//找到下一個需要喚醒的結點
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
// 從後向前找
for (Node t = tail; t != null && t != node; t = t.prev)
//從這裡可以看出，<=0的結點，都是還有效的結點
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
//喚醒
LockSupport.unpark(s.thread);
}
複製程式碼3.2 共享模式下的AQS
共享模式，當然是允許多個執行緒同時獲取到同步狀態,共享模式下的AQS也是不響應中斷的.
很明顯，我們可以將state的初始值設為N（N > 0），表示空閒。每當一個執行緒獲取到同步狀態時，就利用CAS操作讓state減1，直到減到0表示非空閒，其他執行緒就只能加入到同步佇列，進行等待。釋放同步狀態時，需要CAS操作，因為共享模式下，有多個執行緒能獲取到同步狀態。CountDownLatch、Semaphore正是基於此設計的。
例如，CountDownLatch，任務分為N個子執行緒去執行，同步狀態state也初始化為N（注意N要與執行緒個數一致）：
3.2.1 共享模式獲取資源-acquireShared方法
acquireShared在共享模式下執行緒獲取共享資源的頂層入口。它會獲取指定量的資源，獲取成功則直接返回，獲取失敗則進入等待佇列，直到獲取到資源為止，整個過程忽略中斷。
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
複製程式碼流程：
- 先通過tryAcquireShared()嘗試獲取資源，成功則直接返回；
- 失敗則通過doAcquireShared()中的park()進入等待佇列，直到被unpark()/interrupt()併成功獲取到資源才返回(整個等待過程也是忽略中斷響應)。
3.2.2 共享模式獲取資源-tryAcquireShared方法
tryAcquireShared()跟獨佔模式獲取資源方法一樣實現都是由自定義同步器去實現。但AQS規範中已定義好tryAcquireShared()的返回值：
- 負值代表獲取失敗；
- 0代表獲取成功，但沒有剩餘資源；
- 正數表示獲取成功，還有剩餘資源，其他執行緒還可以去獲取。
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
複製程式碼3.2.3 共享模式獲取資源-doAcquireShared方法
doAcquireShared()用於將當前執行緒加入等待佇列尾部休息，直到其他執行緒釋放資源喚醒自己，自己成功拿到相應量的資源後才返回。
private void doAcquireShared(int arg) {
//加入佇列尾部
final Node node = addWaiter(Node.SHARED);
//是否成功標誌
boolean failed = true;
try {
//等待過程中是否被中斷過的標誌
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();//獲取前驅節點
if (p == head) {//如果到head的下一個，因為head是拿到資源的執行緒，此時node被喚醒，很可能是head用完資源來喚醒自己的
int r = tryAcquireShared(arg);//嘗試獲取資源
if (r >= 0) {//成功
setHeadAndPropagate(node, r);//將head指向自己，還有剩餘資源可以再喚醒之後的執行緒
p.next = null; // help GC
if (interrupted)//如果等待過程中被打斷過，此時將中斷補上。
selfInterrupt();
failed = false;
return;
}
}
//判斷狀態，佇列尋找一個適合位置，進入waiting狀態，等著被unpark()或interrupt()
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
複製程式碼3.2.4 共享模式釋放資源-releaseShared方法
releaseShared()用於共享模式下執行緒釋放共享資源，釋放指定量的資源，如果成功釋放且允許喚醒等待執行緒，它會喚醒等待佇列裡的其他執行緒來獲取資源。
public final boolean releaseShared(int arg) {
//嘗試釋放資源
if (tryReleaseShared(arg)) {
//喚醒後繼結點
doReleaseShared();
return true;
}
return false;
}
複製程式碼獨佔模式下的tryRelease()在完全釋放掉資源（state=0）後，才會返回true去喚醒其他執行緒，這主要是基於獨佔下可重入的考量；而共享模式下的releaseShared()則沒有這種要求，共享模式實質就是控制一定量的執行緒併發執行，那麼擁有資源的執行緒在釋放掉部分資源時就可以喚醒後繼等待結點。
https://www.cnblogs.com/waterystone/p/4920797.html
3.2.共享模式釋放資源-doReleaseShared方法
doReleaseShared()主要用於喚醒後繼節點執行緒,當state為正數，去獲取剩餘共享資源；當state=0時去獲取共享資源。
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;
//喚醒後繼
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
// head發生變化
if (h == head)
break;
}
}
複製程式碼歡迎關注微信公眾號【Ccww筆記】，原創技術文章第一時間推出
