多執行緒並行：AQS原始碼分析（2）——共用鎖的實現原理

1 public final void acquireShared(int arg) {
2         //獲取共用資源成功直接返回
3         if (tryAcquireShared(arg) < 0)
4             //獲取資源不成功執行此方法阻塞
5             doAcquireShared(arg);
6     }

 1     private void doAcquireShared(int arg) {
 2         //將當前執行緒加入到同步佇列中，並標記為共用模式
 3         final Node node = addWaiter(Node.SHARED);
 4         //執行緒阻塞等待獲取共用資源的過程中是否發生了異常
 5         boolean failed = true;
 6         try {
 7             //現在在阻塞等待獲取資源的過程中，其它執行緒對此執行緒是否發生了中斷請求
 8             boolean interrupted = false;
 9            
10             /*自旋，找到合適點的點將當前執行緒掛起，再尋找合適點的過程中也不斷嘗試重新獲取共用鎖，因為可能再這個嘗試的過程中，其它執行緒釋放了共用鎖*/
11             for (;;) {
12                 //找到當前節點的前繼節點
13                 final Node p = node.predecessor();
14                 
15                 //當前節點的前繼節點是同步佇列的頭節點
16                 if (p == head) {
17                     //嘗試獲取指定量的共用資源
18                     int r = tryAcquireShared(arg);
19                     //當前Node節點的執行緒成功獲取到了共用資源
20                     if (r >= 0) {
21                         //將當前執行緒Node節點設定為head頭節點，並嘗試喚醒後面的阻塞節點
22                         setHeadAndPropagate(node, r);
23                         p.next = null; // help GC
24                         //等待獲取資源的過程中發生了執行緒中斷的請求是不響應執行緒中斷的，所以這裡要將執行緒中斷補上。
25                         if (interrupted)
26                             //獲取獨佔鎖是放在acquire()方法中處理的，不過作用都一樣。
27                             selfInterrupt();
28                         //表示獲取阻塞獲取資源的過程中沒有發生異常，就不用執行finally中的取消方法了。
29                         failed = false;
30                         return;
31                     }
32                 }
33                 
34                 //找到當前被阻塞執行緒節點的前繼有效節點，將它的狀態設定為Node.SIGNAL
35                 if (shouldParkAfterFailedAcquire(p, node) &&
36                         /**
37                          * 找到了有效前繼節點並它的狀態設定為Node.SIGNAL,那麼我們就可以將當前節點park()，
38                          * 等待前繼節點釋放資源後喚醒它，喚醒之後在進行一次執行緒中斷檢測，進入下次"自旋"。
39                          */
40                     parkAndCheckInterrupt())
41                     interrupted = true;
42             }
43         } finally {
44             //阻塞等待獲取共用資源的時候發生了異常，需要將當前Node節點出隊，上一篇文章中講過，這裡就不再贅述了。
45             if (failed)
46                 cancelAcquire(node);
47         }
48     }

private void setHeadAndPropagate(Node node, int propagate) {
        //後繼節點成功獲取了共用鎖，佇列的"舊head"還沒有改變，將其儲存下來，鎖定到方法的區域性變數做後序的判斷使用；
        Node h = head; // Record old head for check below
        /**
         * 將這個獲取共用鎖成功的後繼節點設定為同步佇列的「新head」,此時同步佇列的head發生變化， 此執行緒還未喚起任何執行緒。
         */
        setHead(node);
        /**
         * 1、h == null這個條件什麼時候成立呢？仔細翻了下AQS中的原始碼發現：
         * 這個setHeadAndPropagate()方法只在共用鎖模式下，同步佇列head的後繼節點成功獲取了共用鎖才會呼叫。
         * 獲取到共用鎖的當前執行緒是同步佇列的頭結點的後繼節點，"舊head"有後繼節點，說明同步佇列不為空,那麼"舊head"也必定不為空，
         * 此方法中第一行通過h == head,在執行setHead(node)方法之前將"舊head"儲存了下來，所以h == null必定不會成立,
         * 至於為什麼這麼寫呢? 查閱了下資料網上說"發現這個是防止空指標異常發生的標準寫法（既如果要取一個物件的某個屬性進行判斷的時候，首先對這個物件進行null判斷）。"
         * 這說的過去吧?
         * 
         * 2、(h = head) == null這個條件什麼時候成立呢？
         * 這個條件也是不可能成立的，下面這種情況應該是最常見的：
         *  （1）、例如有個Semaphore範例s初始化了2個許可，執行緒A首先呼叫s.acquire(2)申請了兩個許可，成功申請到了許可；
         *  （2）、執行緒B呼叫了s.acquire()方法申請一個許可，申請失敗，加入到同步佇列；
         *  （3）、執行緒C呼叫了s.acquire()方法申請一個許可，申請失敗，加入到同步佇列；
         *  （4）、執行緒A呼叫了s.releaseShared(2)方法釋放了兩個許可，再呼叫doReleaseShared()方法，進行同步佇列喚醒；
         *  （6）、首先喚醒了同步佇列中的執行緒B，B執行緒獲取到共用鎖：
         *      a)、如果此時執行緒B還未setHead(Node)方法，還未改變同步佇列的head頭結點，那麼執行緒A的喚醒工作就結束，也僅僅只是喚醒了同步佇列中的執行緒B，
         *              則必定有（h = head） == Node(C) ！= null成立，執行緒C的喚醒工作仍然需要執行緒B去執行；
         *      b)、如果此時執行緒B執行了SetHead(Node)方法，改變了同步佇列的head頭結點，那麼執行緒A同時也會喚醒執行緒C，相當於執行緒A同時喚醒了執行緒B和執行緒C：
         *         1）、如果執行緒C中的setHeadAndPropagate()線上程B前呼叫完畢（即執行緒C執行了setHead()方法改變了同步佇列的head），那麼 (h = head) == Node(C);
         *         2）、如果執行緒C中的setHeadAndPropagate()線上程B之後才呼叫(即執行緒C此時還未執行setHead()方法，未改變同步佇列的head)，那麼 (h = head) == Node(B)
         *  所以綜上所述，只要執行過addWaiter()方法，向同步佇列中新增過執行緒，那麼（h = head）== null必定不成立。只能理解為「防止空指標的標準寫法」。 
         */
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            /**
             * s == null這種情況是可能存在的，如果當前喚醒的這個node節點是同步佇列的尾節點就可能出現node.next == null;
             * s.isShared()指定是共用鎖模式，當前執行緒獲取共用鎖之後，是需要嘗試喚醒同步佇列中的其它執行緒的。
             */
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

 1  private void doReleaseShared() {
 2         for (;;) {
 3             Node h = head;
 4             /**
 5              * h != null保證了佇列不為空，h != tail保證了佇列中有需要喚醒的節點，
 6              * 如果這不能同時滿足說明佇列中沒有需要喚醒的節點，此時h == head這個條件是成立的，
 7              * 直接跳轉到h == head判斷中break，此方法結束執行。
 8              */
 9             if(h != null && h != tail) {
10                 int ws = h.waitStatus;
11                 //如果頭節點的狀態是Node.SIGNAL說明後續有節點是需要喚醒的，
12                 if (ws == Node.SIGNAL) {
13                     /**
14                      * 考慮到共用鎖可以被多執行緒並行持有，可以採用CAS操作，將設定頭節點的狀態為的0的compareAndSetWaitStatus(h,Node.SIGNAL,0)的操作
15                      * 和unparkSuccessor(h)喚醒後節點的操作繫結在一起，這個CAS操作成功，說明頭節點之前肯定是Node.SIGNAL狀態，那麼後繼結點肯定能被喚醒。
16                      */
17                     if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
18                         continue;            // loop to recheck cases
19                     unparkSuccessor(h);
20                 }
21                 /**
22                  * ws == 0說明頭節點的後繼節點已經被喚醒或者即將被喚醒。
23                  */
24                 else if (ws == 0 &&
25                          !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
26                     continue;                // loop on failed CAS
27             }
28             //同步佇列的頭節點未發生變化，跳出喚醒的動作
29             if (h == head)                   // loop if head changed
30                 break;
31         }
32     }