第六章 ReentrantLock源碼解析2--釋放鎖unlock()

最常用的方式：

        int a = 12;
        //注意：通常情況下，這個會設置成一個類變量，比如說Segement中的段鎖與copyOnWriteArrayList中的全局鎖
        final ReentrantLock lock = new ReentrantLock();
        
        lock.lock();//獲取鎖
        try {
            a++;//業務邏輯
        } catch (Exception e) {
        }finally{
            lock.unlock();//釋放鎖
        }

注：關於lock()方法的源碼解析，請參照"第五章 ReentrantLock源碼解析1--獲得非公平鎖與公平鎖lock()"，具體鏈接如下：

http://www.cnblogs.com/java-zhao/p/5131544.html

 

釋放鎖：unlock()

步驟：

1）獲取當前的鎖數量，然后用這個鎖數量減去解鎖的數量（這里為1），最后得出結果c

2）判斷當前線程是不是獨占鎖的線程，如果不是，拋出異常

3）如果c==0，說明鎖被成功釋放，將當前的獨占線程置為null，鎖數量置為0，返回true

4）如果c!=0，說明釋放鎖失敗，鎖數量置為c，返回false

5）如果鎖被釋放成功的話，喚醒距離頭節點最近的一個非取消的節點

源代碼：

 ReentrantLock：unlock()

    /**
     * 釋放這個鎖
     *1）如果當前線程持有這個鎖，則鎖數量被遞減
     *2）如果遞減之后鎖數量為0，則鎖被釋放。
     *如果當前線程不持久有這個鎖，拋出異常
     */
    public void unlock() {
        sync.release(1);
    }

AbstractQueuedSynchronizer：release(int arg)

    /**
     * 釋放鎖（在獨占模式下）
     */
    public final boolean release(int arg) {
        if (tryRelease(arg)) {//如果成功釋放鎖
            Node h = head;//獲取頭節點：（注意：這里的頭節點就是當前正在釋放鎖的節點）
            if (h != null && h.waitStatus != 0)//頭結點存在且等待狀態不是取消
                unparkSuccessor(h);//喚醒距離頭節點最近的一個非取消的節點
            return true;
        }
        return false;
    }

Sync：tryRelease(int releases)

        /**
         * 釋放鎖
         */
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;//獲取現在的鎖數量-傳入的解鎖數量（這里為1）
            if (Thread.currentThread() != getExclusiveOwnerThread())//當前線程不持有鎖
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {//鎖被釋放
                free = true;
                setExclusiveOwnerThread(null);
            }//如果不為0，怎么辦，不釋放了嗎？
            setState(c);
            return free;
        }

AbstractQueuedSynchronizer：unparkSuccessor(Node node)

    /**
     * 喚醒離頭節點node最近的一個非取消的節點
     * @param node 頭節點
     */
    private void unparkSuccessor(Node node) {
        
        int ws = node.waitStatus;
        if (ws < 0)//將ws設為0狀態（即什么狀態都不是）
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * 獲取頭節點的下一個等待狀態不是cancel的節點
         */
        Node s = node.next;//頭節點的下一個節點
        if (s == null || s.waitStatus > 0) {
            s = null;
            /*
             * 注意：從后往前遍歷找到離頭節點最近的一個非取消的節點，從后往前遍歷據說是在入隊（enq()）的時候，可能nodeX.next==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);//喚醒離頭節點最近的一個非取消的節點
    }

 

注意：

在程序的注釋部分有一些疑問，整理成下邊這樣：

• 如果按照開頭的那個程序的話，成功的獲取一個鎖之后，就會在finally里邊解一次鎖，可重入性怎么體現？
• 在找到離頭節點最近的一個非取消的節點，是以從后往前的方式進行的，原因是"從后往前遍歷據說是在入隊（enq()）的時候，可能nodeX.next==null"，但是在讀源碼的時候沒看出來

 第一個問題答案：

可重入性體現在下邊這個程序（就是鎖套鎖，最常見的就是在遞歸中）：

    final ReentrantLock lock = new ReentrantLock();
    public void add(){
        lock.lock();//獲取鎖
        try {
            add();//業務邏輯
        } catch (Exception e) {
        }finally{
            lock.unlock();//釋放鎖
        }
    }

注意：

• 上邊這個程序只是一個示例，在遞歸的使用中，一定要有遞歸結束的條件
• 每有一個lock()方法，就有一個unlock()與之對應，所以在解鎖的時候，只需要把傳遞解鎖數量為1就可以。

第二個問題答案：

記住：如果順着節點頭一直next下去可能會不正確。
舉個例子：A1->A2->A3
現在我們從A1開始往下走，當我們走到A3的時候，就在這時，一個新節點A4入隊，會走下面的入隊代碼：

可以看到步驟1和步驟2整體並不是原子的，也就是說，當執行完CAS的時候但是2還沒執行，這時候隊列為：A1-->A2-->A4，如果你使用next的話，可能就把A3給沒了，但是node.prev = t（即A4.prev = A3），也就是說前驅節點是已經賦過值了的，如果你從隊列結尾A4.prev就會是A3，即A3也丟不了。