java多執行緒並行：以AQS中acquire()方法為例來分析多執行緒間的同步與共同作業

    public final void acquire(int arg) {
        /*嘗試獲取共用資源，嘗試成功直接返回*/
        if (!tryAcquire(arg)  
                /* 1、搶佔共用資源失敗，則將當前節點放入到同步佇列的尾部，並標記為獨佔模式；
                 * 2、使執行緒阻塞在同步佇列中獲取資源，直到獲取成功才返回；如果整個過程中被中斷過就返回true，否則就返回false；*/
                && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
            /*阻塞獲取資源的過程中是不響應執行緒中斷的，內部進行了中斷檢測，檢測到了中斷請求，所以這塊進行執行緒中斷*/
            selfInterrupt();
        }
    }

private Node addWaiter(Node mode) {
        /*以給定的模式將當前執行緒包裝成node節點*/
        Node node = new Node(Thread.currentThread(), mode);
        /*快速採用尾插法，將當前節點插入到同步佇列的隊尾*/
        Node predNode = tail;
        if (predNode != null) {
            /*preNode <-- node*/
            node.prev = predNode;
            /*採用CAS將node設定阻塞佇列的尾節點，設定成功，說明沒有並行*/
            if (compareAndSetTail(tail, node)) {
                predNode.next = node;
                /*尾插法插入成功，則直接返回當前節點*/
                return node;
            }
        }
        /*"自旋"將節點加入到佇列的尾部，直到成功為止*/
        enq(node);
        return node;
    }

 private Node enq(final Node node) {
        /*"自旋"，將給定的節點插入到同步佇列的尾部*/
        for (;;) {
            Node t = tail;
            /*同步佇列為空，則建立一個thread為null的Node節點作為同步佇列的頭結點，並且將尾節點也設定為頭結點*/
            if (t == null) {
                /*CAS操作，設定同步佇列的頭結點*/
                if (compareAndSetHead(new Node())) {
                    /*將尾節點設定為頭結點，進入下次"自旋"*/
                    tail = head;
                }
            }else {
                /*尾部節點不為空，則進行正常新增動作*/
                node.prev = t;
                /*CAS操作，設定同步佇列的頭結點*/
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

final boolean acquireQueued(final Node node, int arg) {
        /*標記阻塞獲取資源的過程中是否發生了異常*/
        boolean failed = true;
        
        try {
            /*標記執行緒阻塞的過程中是否發生了中斷*/
            boolean interrupted = false;
            /*執行緒自旋阻塞*/
            for(;;){
　　　　　　　　　　
                /*獲取當前節點的前驅結點*/
                final Node p = node.predecessor();
                /*1、前驅結點是頭結點，則說明當前執行緒有資格獲取共用資源，嘗試獲取，獲取成功，將當前節點設定為頭結點*/
                if (p == head && tryAcquire(arg)) {
                    /*將當前節點設定為頭結點*/
                    setHead(node);
                    p.next = null; //help GC
                    failed = false;
　　　　　　　　　　　　/*返回執行緒在阻塞的過程中是否接受到了中斷請求*/
                    return interrupted;
                }
                
                /*2、3當前節點的前驅結點不是頭結點，判斷當前執行緒是否可以掛起*/
                if (shouldParkAfterFailedAcquire(p, node)
                        /*4、當前執行緒可以掛起，則掛起執行緒，並且執行緒被unpark()或者interrupt()喚醒，檢查執行緒的狀態*/
                        && parkAndCheckInterrupt()) {
                    interrupted = true;
                }
            }
        }finally{
　　
            if (failed) {
                /*5、阻塞獲取同步資源的時候，發生了異常，將當前Node節點從同步佇列中出隊*/
                cancelAcquire(node);
            }
        }

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        /*判斷前驅結點的狀態，只有前驅結點的狀態為SIGNAL,後繼節點才能被喚醒，所以其可以安心地掛起來了*/
        if (ws == node.waitStatus) {
            return true;
        }
        
        /*ws>0表示前驅結點中的執行緒已經被取消排程了，則認為其是無效節點，繼續向前查詢，直至找到有效狀態的節點*/
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        }else {
            /*前驅結點狀態正常，將前驅結點狀態設定為SIGNAL,則前驅結點釋放資源的時候，就可以嘗試喚醒當前這個後繼節點了*/
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

 1     private void cancelAcquire(Node node) {
 2         //當前節點為空，則說明當前執行緒永遠不會被排程到了，所以直接返回
 3         if (node == null) {
 4             return;
 5         }
 6         
 7         /**
 8          * 接下來將點前Node節點從同步佇列出隊，主要做以下幾件事：
 9          * 1、將當前節點不與任何執行緒繫結，設定當前節點為Node.CANCELLED狀態；
10          * 2、將當前取消節點的前置非取消節點和後置非取消節點"連結"起來；
11          * 3、如果前置節點釋放了鎖，那麼當前取消節點承擔起後續節點的喚醒職責。
12          */
13         
14         //1、取消當前節點與執行緒的繫結
15         node.thread = null;
16         
17         //2、找到當前節點的有效前繼節點pred
18         Node pred = node.prev;
19         while (pred.waitStatus > 0) {
20             //為什麼雙向連結串列從後往前遍歷呢？而不是從前往後遍歷呢？
21             node.prev = pred = pred.prev;
22         }
23         //用作CAS操作時候的條件判斷需要使用的值
24         Node predNext = pred.next;
25         
26         //3、將當前節點設定為取消狀態
27         node.waitStatus = Node.CANCELLED;
28         
29         /**
30          * 接下來就需要將當前取消節點的前後兩個有效節點"連結"起來了，"達成讓當前node節點出隊的目的"。
31          * 這裡按照node節點在同步佇列中的不同位置分了三種情況：
32          * 1、node節點是同步佇列的尾節點tail;
33          * 2、node節點既不是同步佇列頭結點head的後繼節點，也不是尾節點tail;
34          * 3、node節點是同步佇列頭結點head的後繼節點；
35          */
36         
37         //1、node是尾節點，並且執行過程中沒有並行，直接將pred設定為同步佇列的tail
38         if (node == tail && compareAndSetTail(node, pred)) {
39             /*
40              * 此時pred已經設定為同步佇列的tail，需要通過CAS操作，將pred的next指向null,沒有節點再參照node，就完成了node節點的出隊42              */
43             compareAndSetNext(pred, predNext, null);
44         }else {
45             /*
46              * 2、node不是尾節點，也不是頭結點head的後繼節點,那麼當前節點node出隊以後，node的有效前繼結點pred，
47              *  就有義務在它自身釋放資源的時候，喚醒node的有效後繼節點successor,即將pred的狀態設定為Node.SIGNAL;
48              */
49             int ws;
50             //能執行到這裡，說明當前node節點不是head的後繼節點，也不是同步佇列tail節點
51             if (pred != head &&
52                     ((ws = pred.waitStatus) == Node.SIGNAL ||
53                     //前繼節點狀態雖然有效但不是SIGNAL,採用CAS操作設定為SIGNAL確保後繼有效節點可以被喚醒
54                     (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) && 
55                     pred.thread != null) {
56                 Node next = node.next;
57                 //只負責喚醒有效後繼節點
58                 if (next != null && next.waitStatus <= 0) {
59                     /**
60                      * 下面這段程式碼相當於將pred-->next，我們提到這個同步佇列是個雙向佇列，那麼pred<--next這是誰執行的呢？
61                      * 答案是其他執行緒：其它執行緒在後序的獲取共用資源在同步佇列中阻塞的時候，呼叫shouldParkAfterFailedAcquire()方法，
62                      * 從後向前遍歷佇列，尋找能喚醒它的有效前繼節點，當找到node的時候，因為它的狀態已經是Node.CANCELLED,所以會忽略node節點，
63                      * 直到遍歷到有效前繼節點pred,將next.prev執行pred,即next--->pred，沒有節點再參照node節點，所以node節點至此才完成出隊。
64                      */
65                     compareAndSetNext(pred, predNext, next);
66                 }
67             }else {
68                 //3、說明node節點是同步佇列head的後繼節點，呼叫unparkSuccessor(Node)喚醒其他執行緒，達到讓當前node"出隊"。
69                 unparkSuccessor(node);
70             }
71             
72             node.next = node;//help GC
73         }
74     }

 1   private void unparkSuccessor(Node node) {
 2         /*
 3          * If status is negative (i.e., possibly needing signal) try
 4          * to clear in anticipation of signalling.  It is OK if this
 5          * fails or if status is changed by waiting thread.
 6          */
 7         //在這裡，這個節點其實是同步佇列的頭結點，頭結點喚醒後繼節點之後，使命就完成了，所以應該將其狀態置為0
 8         int ws = node.waitStatus;
 9         if (ws < 0)
10             compareAndSetWaitStatus(node, ws, 0);
11 
12         /*
13          * Thread to unpark is held in successor, which is normally
14          * just the next node.  But if cancelled or apparently null,
15          * traverse backwards from tail to find the actual
16          * non-cancelled successor.
17          */
18         Node s = node.next;
19         //因為s.next相當於從同步佇列的頭部遍歷所以可能會出現s == null的情況，上面分析過原因，不再贅述了。
20         if (s == null || s.waitStatus > 0) {
21             s = null;
22             //從同步佇列的尾部向前遍歷，找到當前node節點(頭結點)的最近的有效後繼節點
23             for (Node t = tail; t != null && t != node; t = t.prev)
24                 if (t.waitStatus <= 0)
25                     s = t;
26         }
27         
28         /**
29          * 找到最近的有效後繼節點，則喚醒後繼節點中的執行緒在parkAndCheckInterrupt()方法上的阻塞，去嘗試競爭共用資源，
30          * 這就體現了執行緒之間的共同作業，而在這個競爭的過程中也會忽略這個Node.CANCELLED狀態的節點，這當前node節點也就放棄了競爭共用資源的機會，相當於出隊了。
31          */
32         if (s != null)
33             LockSupport.unpark(s.thread);
34     }