Java並發之AQS詳解

阿新 • • 發佈：2018-08-19

leg 同步器回收 thread true 判斷 monit map 重入

一、概述

　　談到並發，不得不談ReentrantLock；而談到ReentrantLock，不得不談AbstractQueuedSynchronized（AQS）！

　　類如其名，抽象的隊列式的同步器，AQS定義了一套多線程訪問共享資源的同步器框架，許多同步類實現都依賴於它，如常用的ReentrantLock/Semaphore/CountDownLatch...。

　　以下是本文的目錄大綱：

1. 概述
2. 框架
3. 源碼詳解
4. 簡單應用

　　若有不正之處，請諒解和批評指正，不勝感激。

　　請尊重作者勞動成果，轉載請標明原文鏈接：http://www.cnblogs.com/waterystone/p/4920797.html

二、框架

技術分享圖片

　　它維護了一個volatile int state（代表共享資源）和一個FIFO線程等待隊列（多線程爭用資源被阻塞時會進入此隊列）。這裏volatile是核心關鍵詞，具體volatile的語義，在此不述。state的訪問方式有三種:

getState()
setState()
compareAndSetState()

　　AQS定義兩種資源共享方式：Exclusive（獨占，只有一個線程能執行，如ReentrantLock）和Share（共享，多個線程可同時執行，如Semaphore/CountDownLatch）。

　　不同的自定義同步器爭用共享資源的方式也不同。自定義同步器在實現時只需要實現共享資源state的獲取與釋放方式即可

，至於具體線程等待隊列的維護（如獲取資源失敗入隊/喚醒出隊等），AQS已經在頂層實現好了。自定義同步器實現時主要實現以下幾種方法：

isHeldExclusively()：該線程是否正在獨占資源。只有用到condition才需要去實現它。
tryAcquire(int)：獨占方式。嘗試獲取資源，成功則返回true，失敗則返回false。
tryRelease(int)：獨占方式。嘗試釋放資源，成功則返回true，失敗則返回false。
tryAcquireShared(int)：共享方式。嘗試獲取資源。負數表示失敗；0表示成功，但沒有剩余可用資源；正數表示成功，且有剩余資源。
tryReleaseShared(int)：共享方式。嘗試釋放資源，成功則返回true，失敗則返回false。

　　以ReentrantLock為例，state初始化為0，表示未鎖定狀態。A線程lock()時，會調用tryAcquire()獨占該鎖並將state+1。此後，其他線程再tryAcquire()時就會失敗，直到A線程unlock()到state=0（即釋放鎖）為止，其它線程才有機會獲取該鎖。當然，釋放鎖之前，A線程自己是可以重復獲取此鎖的（state會累加），這就是可重入的概念。但要註意，獲取多少次就要釋放多麽次，這樣才能保證state是能回到零態的。

　　再以CountDownLatch以例，任務分為N個子線程去執行，state也初始化為N（註意N要與線程個數一致）。這N個子線程是並行執行的，每個子線程執行完後countDown()一次，state會CAS減1。等到所有子線程都執行完後(即state=0)，會unpark()主調用線程，然後主調用線程就會從await()函數返回，繼續後余動作。

　　一般來說，自定義同步器要麽是獨占方法，要麽是共享方式，他們也只需實現tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一種即可。但AQS也支持自定義同步器同時實現獨占和共享兩種方式，如ReentrantReadWriteLock。

三、源碼詳解

　　本節開始講解AQS的源碼實現。依照acquire-release、acquireShared-releaseShared的次序來。

3.1 acquire(int)

　　此方法是獨占模式下線程獲取共享資源的頂層入口。如果獲取到資源，線程直接返回，否則進入等待隊列，直到獲取到資源為止，且整個過程忽略中斷的影響。這也正是lock()的語義，當然不僅僅只限於lock()。獲取到資源後，線程就可以去執行其臨界區代碼了。下面是acquire()的源碼：

1 public final void acquire(int arg) {
2     if (!tryAcquire(arg) &&
3         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
4         selfInterrupt();
5 }

　　函數流程如下：

1. tryAcquire()嘗試直接去獲取資源，如果成功則直接返回；
2. addWaiter()將該線程加入等待隊列的尾部，並標記為獨占模式；
3. acquireQueued()使線程在等待隊列中獲取資源，一直獲取到資源後才返回。如果在整個等待過程中被中斷過，則返回true，否則返回false。
4. 如果線程在等待過程中被中斷過，它是不響應的。只是獲取資源後才再進行自我中斷selfInterrupt()，將中斷補上。

　　這時單憑這4個抽象的函數來看流程還有點朦朧，不要緊，看完接下來的分析後，你就會明白了。就像《大話西遊》裏唐僧說的：等你明白了舍生取義的道理，你自然會回來和我唱這首歌的。

3.1.1 tryAcquire(int)

　　此方法嘗試去獲取獨占資源。如果獲取成功，則直接返回true，否則直接返回false。這也正是tryLock()的語義，還是那句話，當然不僅僅只限於tryLock()。如下是tryAcquire()的源碼：

1     protected boolean tryAcquire(int arg) {
2         throw new UnsupportedOperationException();
3     }

　　什麽？直接throw異常？說好的功能呢？好吧，還記得概述裏講的AQS只是一個框架，具體資源的獲取/釋放方式交由自定義同步器去實現嗎？就是這裏了！！！AQS這裏只定義了一個接口，具體資源的獲取交由自定義同步器去實現了（通過state的get/set/CAS）！！！至於能不能重入，能不能加塞，那就看具體的自定義同步器怎麽去設計了！！！當然，自定義同步器在進行資源訪問時要考慮線程安全的影響。

　　這裏之所以沒有定義成abstract，是因為獨占模式下只用實現tryAcquire-tryRelease，而共享模式下只用實現tryAcquireShared-tryReleaseShared。如果都定義成abstract，那麽每個模式也要去實現另一模式下的接口。說到底，Doug Lea還是站在咱們開發者的角度，盡量減少不必要的工作量。

3.1.2 addWaiter(Node)

　　此方法用於將當前線程加入到等待隊列的隊尾，並返回當前線程所在的結點。還是上源碼吧：

 1 private Node addWaiter(Node mode) {
 2     //以給定模式構造結點。mode有兩種：EXCLUSIVE（獨占）和SHARED（共享）
 3     Node node = new Node(Thread.currentThread(), mode);
 4     
 5     //嘗試快速方式直接放到隊尾。
 6     Node pred = tail;
 7     if (pred != null) {
 8         node.prev = pred;
 9         if (compareAndSetTail(pred, node)) {
10             pred.next = node;
11             return node;
12         }
13     }
14     
15     //上一步失敗則通過enq入隊。
16     enq(node);
17     return node;
18 }

不用再說了，直接看註釋吧。

3.1.2.1 enq(Node)

　　此方法用於將node加入隊尾。源碼如下：

 1 private Node enq(final Node node) {
 2     //CAS"自旋"，直到成功加入隊尾
 3     for (;;) {
 4         Node t = tail;
 5         if (t == null) { // 隊列為空，創建一個空的標誌結點作為head結點，並將tail也指向它。
 6             if (compareAndSetHead(new Node()))
 7                 tail = head;
 8         } else {//正常流程，放入隊尾
 9             node.prev = t;
10             if (compareAndSetTail(t, node)) {
11                 t.next = node;
12                 return t;
13             }
14         }
15     }
16 }

如果你看過AtomicInteger.getAndIncrement()函數源碼，那麽相信你一眼便看出這段代碼的精華。CAS自旋volatile變量，是一種很經典的用法。還不太了解的，自己去百度一下吧。

3.1.3 acquireQueued(Node, int)

　　OK，通過tryAcquire()和addWaiter()，該線程獲取資源失敗，已經被放入等待隊列尾部了。聰明的你立刻應該能想到該線程下一部該幹什麽了吧：進入等待狀態休息，直到其他線程徹底釋放資源後喚醒自己，自己再拿到資源，然後就可以去幹自己想幹的事了。沒錯，就是這樣！是不是跟醫院排隊拿號有點相似~~acquireQueued()就是幹這件事：在等待隊列中排隊拿號（中間沒其它事幹可以休息），直到拿到號後再返回。這個函數非常關鍵，還是上源碼吧：

 1 final boolean acquireQueued(final Node node, int arg) {
 2     boolean failed = true;//標記是否成功拿到資源
 3     try {
 4         boolean interrupted = false;//標記等待過程中是否被中斷過
 5         
 6         //又是一個“自旋”！
 7         for (;;) {
 8             final Node p = node.predecessor();//拿到前驅
 9             //如果前驅是head，即該結點已成老二，那麽便有資格去嘗試獲取資源（可能是老大釋放完資源喚醒自己的，當然也可能被interrupt了）。
10             if (p == head && tryAcquire(arg)) {
11                 setHead(node);//拿到資源後，將head指向該結點。所以head所指的標桿結點，就是當前獲取到資源的那個結點或null。
12                 p.next = null; // setHead中node.prev已置為null，此處再將head.next置為null，就是為了方便GC回收以前的head結點。也就意味著之前拿完資源的結點出隊了！
13                 failed = false;
14                 return interrupted;//返回等待過程中是否被中斷過
15             }
16             
17             //如果自己可以休息了，就進入waiting狀態，直到被unpark()
18             if (shouldParkAfterFailedAcquire(p, node) &&
19                 parkAndCheckInterrupt())
20                 interrupted = true;//如果等待過程中被中斷過，哪怕只有那麽一次，就將interrupted標記為true
21         }
22     } finally {
23         if (failed)
24             cancelAcquire(node);
25     }
26 }

到這裏了，我們先不急著總結acquireQueued()的函數流程，先看看shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()具體幹些什麽。

3.1.3.1 shouldParkAfterFailedAcquire(Node, Node)

　　此方法主要用於檢查狀態，看看自己是否真的可以去休息了（進入waiting狀態，如果線程狀態轉換不熟，可以參考本人上一篇寫的Thread詳解），萬一隊列前邊的線程都放棄了只是瞎站著，那也說不定，對吧！

 1 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
 2     int ws = pred.waitStatus;//拿到前驅的狀態
 3     if (ws == Node.SIGNAL)
 4         //如果已經告訴前驅拿完號後通知自己一下，那就可以安心休息了
 5         return true;
 6     if (ws > 0) {
 7         /*
 8          * 如果前驅放棄了，那就一直往前找，直到找到最近一個正常等待的狀態，並排在它的後邊。
 9          * 註意：那些放棄的結點，由於被自己“加塞”到它們前邊，它們相當於形成一個無引用鏈，稍後就會被保安大叔趕走了(GC回收)！
10          */
11         do {
12             node.prev = pred = pred.prev;
13         } while (pred.waitStatus > 0);
14         pred.next = node;
15     } else {
16          //如果前驅正常，那就把前驅的狀態設置成SIGNAL，告訴它拿完號後通知自己一下。有可能失敗，人家說不定剛剛釋放完呢！
17         compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
18     }
19     return false;
20 }

整個流程中，如果前驅結點的狀態不是SIGNAL，那麽自己就不能安心去休息，需要去找個安心的休息點，同時可以再嘗試下看有沒有機會輪到自己拿號。

3.1.3.2 parkAndCheckInterrupt()

　　如果線程找好安全休息點後，那就可以安心去休息了。此方法就是讓線程去休息，真正進入等待狀態。

1 private final boolean parkAndCheckInterrupt() {
2     LockSupport.park(this);//調用park()使線程進入waiting狀態
3     return Thread.interrupted();//如果被喚醒，查看自己是不是被中斷的。
4 }

　　park()會讓當前線程進入waiting狀態。在此狀態下，有兩種途徑可以喚醒該線程：1）被unpark()；2）被interrupt()。（再說一句，如果線程狀態轉換不熟，可以參考本人寫的Thread詳解）。需要註意的是，Thread.interrupted()會清除當前線程的中斷標記位。

3.1.3.3 小結

　　OK，看了shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()，現在讓我們再回到acquireQueued()，總結下該函數的具體流程：

結點進入隊尾後，檢查狀態，找到安全休息點；
調用park()進入waiting狀態，等待unpark()或interrupt()喚醒自己；
被喚醒後，看自己是不是有資格能拿到號。如果拿到，head指向當前結點，並返回從入隊到拿到號的整個過程中是否被中斷過；如果沒拿到，繼續流程1。

3.1.4 小結

　　OKOK，acquireQueued()分析完之後，我們接下來再回到acquire()！再貼上它的源碼吧：

1 public final void acquire(int arg) {
2     if (!tryAcquire(arg) &&
3         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
4         selfInterrupt();
5 }

再來總結下它的流程吧：

調用自定義同步器的tryAcquire()嘗試直接去獲取資源，如果成功則直接返回；
沒成功，則addWaiter()將該線程加入等待隊列的尾部，並標記為獨占模式；
acquireQueued()使線程在等待隊列中休息，有機會時（輪到自己，會被unpark()）會去嘗試獲取資源。獲取到資源後才返回。如果在整個等待過程中被中斷過，則返回true，否則返回false。
如果線程在等待過程中被中斷過，它是不響應的。只是獲取資源後才再進行自我中斷selfInterrupt()，將中斷補上。

由於此函數是重中之重，我再用流程圖總結一下：

技術分享圖片

至此，acquire()的流程終於算是告一段落了。這也就是ReentrantLock.lock()的流程，不信你去看其lock()源碼吧，整個函數就是一條acquire(1)！！！

3.2 release(int)

　　上一小節已經把acquire()說完了，這一小節就來講講它的反操作release()吧。此方法是獨占模式下線程釋放共享資源的頂層入口。它會釋放指定量的資源，如果徹底釋放了（即state=0）,它會喚醒等待隊列裏的其他線程來獲取資源。這也正是unlock()的語義，當然不僅僅只限於unlock()。下面是release()的源碼：

1 public final boolean release(int arg) {
2     if (tryRelease(arg)) {
3         Node h = head;//找到頭結點
4         if (h != null && h.waitStatus != 0)
5             unparkSuccessor(h);//喚醒等待隊列裏的下一個線程
6         return true;
7     }
8     return false;
9 }

　　邏輯並不復雜。它調用tryRelease()來釋放資源。有一點需要註意的是，它是根據tryRelease()的返回值來判斷該線程是否已經完成釋放掉資源了！所以自定義同步器在設計tryRelease()的時候要明確這一點！！

3.2.1 tryRelease(int)

　　此方法嘗試去釋放指定量的資源。下面是tryRelease()的源碼：

1 protected boolean tryRelease(int arg) {
2     throw new UnsupportedOperationException();
3 }

　　跟tryAcquire()一樣，這個方法是需要獨占模式的自定義同步器去實現的。正常來說，tryRelease()都會成功的，因為這是獨占模式，該線程來釋放資源，那麽它肯定已經拿到獨占資源了，直接減掉相應量的資源即可(state-=arg)，也不需要考慮線程安全的問題。但要註意它的返回值，上面已經提到了，release()是根據tryRelease()的返回值來判斷該線程是否已經完成釋放掉資源了！所以自義定同步器在實現時，如果已經徹底釋放資源(state=0)，要返回true，否則返回false。

3.2.2 unparkSuccessor(Node)

　　此方法用於喚醒等待隊列中下一個線程。下面是源碼：

 1 private void unparkSuccessor(Node node) {
 2     //這裏，node一般為當前線程所在的結點。
 3     int ws = node.waitStatus;
 4     if (ws < 0)//置零當前線程所在的結點狀態，允許失敗。
 5         compareAndSetWaitStatus(node, ws, 0);
 6 
 7     Node s = node.next;//找到下一個需要喚醒的結點s
 8     if (s == null || s.waitStatus > 0) {//如果為空或已取消
 9         s = null;
10         for (Node t = tail; t != null && t != node; t = t.prev)
11             if (t.waitStatus <= 0)//從這裏可以看出，<=0的結點，都是還有效的結點。
12                 s = t;
13     }
14     if (s != null)
15         LockSupport.unpark(s.thread);//喚醒
16 }

　　這個函數並不復雜。一句話概括：用unpark()喚醒等待隊列中最前邊的那個未放棄線程，這裏我們也用s來表示吧。此時，再和acquireQueued()聯系起來，s被喚醒後，進入if (p == head && tryAcquire(arg))的判斷（即使p!=head也沒關系，它會再進入shouldParkAfterFailedAcquire()尋找一個安全點。這裏既然s已經是等待隊列中最前邊的那個未放棄線程了，那麽通過shouldParkAfterFailedAcquire()的調整，s也必然會跑到head的next結點，下一次自旋p==head就成立啦），然後s把自己設置成head標桿結點，表示自己已經獲取到資源了，acquire()也返回了！！And then, DO what you WANT!

3.2.3 小結

　　release()是獨占模式下線程釋放共享資源的頂層入口。它會釋放指定量的資源，如果徹底釋放了（即state=0）,它會喚醒等待隊列裏的其他線程來獲取資源。

3.3 acquireShared(int)

　　此方法是共享模式下線程獲取共享資源的頂層入口。它會獲取指定量的資源，獲取成功則直接返回，獲取失敗則進入等待隊列，直到獲取到資源為止，整個過程忽略中斷。下面是acquireShared()的源碼：

1 public final void acquireShared(int arg) {
2     if (tryAcquireShared(arg) < 0)
3         doAcquireShared(arg);
4 }

　　這裏tryAcquireShared()依然需要自定義同步器去實現。但是AQS已經把其返回值的語義定義好了：負值代表獲取失敗；0代表獲取成功，但沒有剩余資源；正數表示獲取成功，還有剩余資源，其他線程還可以去獲取。所以這裏acquireShared()的流程就是：

1. tryAcquireShared()嘗試獲取資源，成功則直接返回；
2. 失敗則通過doAcquireShared()進入等待隊列，直到獲取到資源為止才返回。

3.3.1 doAcquireShared(int)

　　此方法用於將當前線程加入等待隊列尾部休息，直到其他線程釋放資源喚醒自己，自己成功拿到相應量的資源後才返回。下面是doAcquireShared()的源碼：

 1 private void doAcquireShared(int arg) {
 2     final Node node = addWaiter(Node.SHARED);//加入隊列尾部
 3     boolean failed = true;//是否成功標誌
 4     try {
 5         boolean interrupted = false;//等待過程中是否被中斷過的標誌
 6         for (;;) {
 7             final Node p = node.predecessor();//前驅
 8             if (p == head) {//如果到head的下一個，因為head是拿到資源的線程，此時node被喚醒，很可能是head用完資源來喚醒自己的
 9                 int r = tryAcquireShared(arg);//嘗試獲取資源
10                 if (r >= 0) {//成功
11                     setHeadAndPropagate(node, r);//將head指向自己，還有剩余資源可以再喚醒之後的線程
12                     p.next = null; // help GC
13                     if (interrupted)//如果等待過程中被打斷過，此時將中斷補上。
14                         selfInterrupt();
15                     failed = false;
16                     return;
17                 }
18             }
19             
20             //判斷狀態，尋找安全點，進入waiting狀態，等著被unpark()或interrupt()
21             if (shouldParkAfterFailedAcquire(p, node) &&
22                 parkAndCheckInterrupt())
23                 interrupted = true;
24         }
25     } finally {
26         if (failed)
27             cancelAcquire(node);
28     }
29 }

　　有木有覺得跟acquireQueued()很相似？對，其實流程並沒有太大區別。只不過這裏將補中斷的selfInterrupt()放到doAcquireShared()裏了，而獨占模式是放到acquireQueued()之外，其實都一樣，不知道Doug Lea是怎麽想的。

　　跟獨占模式比，還有一點需要註意的是，這裏只有線程是head.next時（“老二”），才會去嘗試獲取資源，有剩余的話還會喚醒之後的隊友。那麽問題就來了，假如老大用完後釋放了5個資源，而老二需要6個，老三需要1個，老四需要2個。因為老大先喚醒老二，老二一看資源不夠自己用繼續park()，也更不會去喚醒老三和老四了。獨占模式，同一時刻只有一個線程去執行，這樣做未嘗不可；但共享模式下，多個線程是可以同時執行的，現在因為老二的資源需求量大，而把後面量小的老三和老四也都卡住了。

3.3.1.1 setHeadAndPropagate(Node, int)

 1 private void setHeadAndPropagate(Node node, int propagate) {
 2     Node h = head; 
 3     setHead(node);//head指向自己
 4      //如果還有剩余量，繼續喚醒下一個鄰居線程
 5     if (propagate > 0 || h == null || h.waitStatus < 0) {
 6         Node s = node.next;
 7         if (s == null || s.isShared())
 8             doReleaseShared();
 9     }
10 }

　　此方法在setHead()的基礎上多了一步，就是自己蘇醒的同時，如果條件符合（比如還有剩余資源），還會去喚醒後繼結點，畢竟是共享模式！

　　doReleaseShared()我們留著下一小節的releaseShared()裏來講。

3.3.2 小結

　　OK，至此，acquireShared()也要告一段落了。讓我們再梳理一下它的流程：

tryAcquireShared()嘗試獲取資源，成功則直接返回；
失敗則通過doAcquireShared()進入等待隊列park()，直到被unpark()/interrupt()並成功獲取到資源才返回。整個等待過程也是忽略中斷的。

　　其實跟acquire()的流程大同小異，只不過多了個自己拿到資源後，還會去喚醒後繼隊友的操作（這才是共享嘛）。

3.4 releaseShared()

　　上一小節已經把acquireShared()說完了，這一小節就來講講它的反操作releaseShared()吧。此方法是共享模式下線程釋放共享資源的頂層入口。它會釋放指定量的資源，如果徹底釋放了（即state=0）,它會喚醒等待隊列裏的其他線程來獲取資源。下面是releaseShared()的源碼：

1 public final boolean releaseShared(int arg) {
2     if (tryReleaseShared(arg)) {//嘗試釋放資源
3         doReleaseShared();//喚醒後繼結點
4         return true;
5     }
6     return false;
7 }

　　此方法的流程也比較簡單，一句話：釋放掉資源後，喚醒後繼。跟獨占模式下的release()相似，但有一點稍微需要註意：獨占模式下的tryRelease()在完全釋放掉資源（state=0）後，才會返回true去喚醒其他線程，這主要是基於可重入的考量；而共享模式下的releaseShared()則沒有這種要求，一是共享的實質--多線程可並發執行；二是共享模式基本也不會重入吧（至少我還沒見過），所以自定義同步器可以根據需要決定返回值。

3.4.1 doReleaseShared()

　　此方法主要用於喚醒後繼。下面是它的源碼：

 1 private void doReleaseShared() {
 2     for (;;) {
 3         Node h = head;
 4         if (h != null && h != tail) {
 5             int ws = h.waitStatus;
 6             if (ws == Node.SIGNAL) {
 7                 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
 8                     continue;
 9                 unparkSuccessor(h);//喚醒後繼
10             }
11             else if (ws == 0 &&
12                      !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
13                 continue;
14         }
15         if (h == head)// head發生變化
16             break;
17     }
18 }

3.5 小結

　　本節我們詳解了獨占和共享兩種模式下獲取-釋放資源(acquire-release、acquireShared-releaseShared)的源碼，相信大家都有一定認識了。值得註意的是，acquire()和acquireSahred()兩種方法下，線程在等待隊列中都是忽略中斷的。AQS也支持響應中斷的，acquireInterruptibly()/acquireSharedInterruptibly()即是，這裏相應的源碼跟acquire()和acquireSahred()差不多，這裏就不再詳解了。

四、簡單應用

　　通過前邊幾個章節的學習，相信大家已經基本理解AQS的原理了。這裏再將“框架”一節中的一段話復制過來：

　　不同的自定義同步器爭用共享資源的方式也不同。自定義同步器在實現時只需要實現共享資源state的獲取與釋放方式即可，至於具體線程等待隊列的維護（如獲取資源失敗入隊/喚醒出隊等），AQS已經在頂層實現好了。自定義同步器實現時主要實現以下幾種方法：

isHeldExclusively()：該線程是否正在獨占資源。只有用到condition才需要去實現它。
tryAcquire(int)：獨占方式。嘗試獲取資源，成功則返回true，失敗則返回false。
tryRelease(int)：獨占方式。嘗試釋放資源，成功則返回true，失敗則返回false。
tryAcquireShared(int)：共享方式。嘗試獲取資源。負數表示失敗；0表示成功，但沒有剩余可用資源；正數表示成功，且有剩余資源。
tryReleaseShared(int)：共享方式。嘗試釋放資源，成功則返回true，失敗則返回false。

　　OK，下面我們就以AQS源碼裏的Mutex為例，講一下AQS的簡單應用。

4.1 Mutex（互斥鎖）

　　Mutex是一個不可重入的互斥鎖實現。鎖資源（AQS裏的state）只有兩種狀態：0表示未鎖定，1表示鎖定。下邊是Mutex的核心源碼：

 1 class Mutex implements Lock, java.io.Serializable {
 2     // 自定義同步器
 3     private static class Sync extends AbstractQueuedSynchronizer {
 4         // 判斷是否鎖定狀態
 5         protected boolean isHeldExclusively() {
 6             return getState() == 1;
 7         }
 8 
 9         // 嘗試獲取資源，立即返回。成功則返回true，否則false。
10         public boolean tryAcquire(int acquires) {
11             assert acquires == 1; // 這裏限定只能為1個量
12             if (compareAndSetState(0, 1)) {//state為0才設置為1，不可重入！
13                 setExclusiveOwnerThread(Thread.currentThread());//設置為當前線程獨占資源
14                 return true;
15             }
16             return false;
17         }
18 
19         // 嘗試釋放資源，立即返回。成功則為true，否則false。
20         protected boolean tryRelease(int releases) {
21             assert releases == 1; // 限定為1個量
22             if (getState() == 0)//既然來釋放，那肯定就是已占有狀態了。只是為了保險，多層判斷！
23                 throw new IllegalMonitorStateException();
24             setExclusiveOwnerThread(null);
25             setState(0);//釋放資源，放棄占有狀態
26             return true;
27         }
28     }
29 
30     // 真正同步類的實現都依賴繼承於AQS的自定義同步器！
31     private final Sync sync = new Sync();
32 
33     //lock<-->acquire。兩者語義一樣：獲取資源，即便等待，直到成功才返回。
34     public void lock() {
35         sync.acquire(1);
36     }
37 
38     //tryLock<-->tryAcquire。兩者語義一樣：嘗試獲取資源，要求立即返回。成功則為true，失敗則為false。
39     public boolean tryLock() {
40         return sync.tryAcquire(1);
41     }
42 
43     //unlock<-->release。兩者語文一樣：釋放資源。
44     public void unlock() {
45         sync.release(1);
46     }
47 
48     //鎖是否占有狀態
49     public boolean isLocked() {
50         return sync.isHeldExclusively();
51     }
52 }

　　同步類在實現時一般都將自定義同步器（sync）定義為內部類，供自己使用；而同步類自己（Mutex）則實現某個接口，對外服務。當然，接口的實現要直接依賴sync，它們在語義上也存在某種對應關系！！而sync只用實現資源state的獲取-釋放方式tryAcquire-tryRelelase，至於線程的排隊、等待、喚醒等，上層的AQS都已經實現好了，我們不用關心。

　　除了Mutex，ReentrantLock/CountDownLatch/Semphore這些同步類的實現方式都差不多，不同的地方就在獲取-釋放資源的方式tryAcquire-tryRelelase。掌握了這點，AQS的核心便被攻破了！

　　OK，至此，整個AQS的講解也要落下帷幕了。希望本文能夠對學習Java並發編程的同學有所借鑒，中間寫的有不對的地方，也歡迎討論和指正~

Java並發之AQS詳解

leg 同步器回收 thread true 判斷 monit map 重入一、概述　　談到並發，不得不談ReentrantLock；而談到ReentrantLock，不得不談AbstractQueuedSynchronized（AQS）！　　類如其名，抽象的隊列式

Java並發之AQS詳解

一、概述

二、框架

三、源碼詳解

3.1 acquire(int)

3.1.1 tryAcquire(int)

3.1.2 addWaiter(Node)

3.1.2.1 enq(Node)

3.1.3 acquireQueued(Node, int)

3.1.3.1 shouldParkAfterFailedAcquire(Node, Node)

3.1.3.2 parkAndCheckInterrupt()

3.1.3.3 小結

3.1.4 小結

3.2 release(int)

3.2.1 tryRelease(int)

3.2.2 unparkSuccessor(Node)

3.2.3 小結

3.3 acquireShared(int)

3.3.1 doAcquireShared(int)

3.3.1.1 setHeadAndPropagate(Node, int)

3.3.2 小結

3.4 releaseShared()

3.4.1 doReleaseShared()

3.5 小結

四、簡單應用

4.1 Mutex（互斥鎖）

相關推薦