釋放公平鎖(基於JDK1.7.0_40)

1. unlock()

unlock()在ReentrantLock.java中實現的，源碼如下：

public void unlock() {
    sync.release(1);
}

說明：
unlock()是解鎖函數，它是通過AQS的release()函數來實現的。
在這裏，“1”的含義和“獲取鎖的函數acquire(1)的含義”一樣，它是設置“釋放鎖的狀態”的參數。由於“公平鎖”是可重入的，所以對於同一個線程，每釋放鎖一次，鎖的狀態-1。

關於AQS, ReentrantLock 和 sync的關系如下：

public class ReentrantLock implements
 
 Lock, java.io.Serializable {

    private final Sync sync;

    abstract static class Sync extends AbstractQueuedSynchronizer {
        ...
    }

    ...
}

從中，我們發現：sync是ReentrantLock.java中的成員對象，而Sync是AQS的子類。

2. release()

release()在AQS中實現的，源碼如下：

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h 
 
= head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

說明：
release()會先調用tryRelease()來嘗試釋放當前線程鎖持有的鎖。成功的話，則喚醒後繼等待線程，並返回true。否則，直接返回false。

3. tryRelease()

tryRelease()在ReentrantLock.java的Sync類中實現，源碼如下：

protected final boolean
 
 tryRelease(int releases) {
    // c是本次釋放鎖之後的狀態
    int c = getState() - releases;
    // 如果“當前線程”不是“鎖的持有者”，則拋出異常！
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();

    boolean free = false;
    // 如果“鎖”已經被當前線程徹底釋放，則設置“鎖”的持有者為null，即鎖是可獲取狀態。
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 設置當前線程的鎖的狀態。
    setState(c);
    return free;
}

說明：
tryRelease()的作用是嘗試釋放鎖。
(01) 如果“當前線程”不是“鎖的持有者”，則拋出異常。
(02) 如果“當前線程”在本次釋放鎖操作之後，對鎖的擁有狀態是0(即，當前線程徹底釋放該“鎖”)，則設置“鎖”的持有者為null，即鎖是可獲取狀態。同時，更新當前線程的鎖的狀態為0。
getState(), setState()在前一章已經介紹過，這裏不再說明。
getExclusiveOwnerThread(), setExclusiveOwnerThread()在AQS的父類AbstractOwnableSynchronizer.java中定義，源碼如下：

public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {

    // “鎖”的持有線程
    private transient Thread exclusiveOwnerThread;

    // 設置“鎖的持有線程”為t
    protected final void setExclusiveOwnerThread(Thread t) {
        exclusiveOwnerThread = t;
    }

    // 獲取“鎖的持有線程”
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
   
    ...
}

4. unparkSuccessor()

在release()中“當前線程”釋放鎖成功的話，會喚醒當前線程的後繼線程。
根據CLH隊列的FIFO規則，“當前線程”(即已經獲取鎖的線程)肯定是head；如果CLH隊列非空的話，則喚醒鎖的下一個等待線程。
下面看看unparkSuccessor()的源碼，它在AQS中實現。

private void unparkSuccessor(Node node) {
    // 獲取當前線程的狀態
    int ws = node.waitStatus;
    // 如果狀態<0，則設置狀態=0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    //獲取當前節點的“有效的後繼節點”，無效的話，則通過for循環進行獲取。
    // 這裏的有效，是指“後繼節點對應的線程狀態<=0”
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = 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);
}

說明：
unparkSuccessor()的作用是“喚醒當前線程的後繼線程”。後繼線程被喚醒之後，就可以獲取該鎖並恢復運行了。
關於node.waitStatus的說明，請參考“上一章關於Node類的介紹”。

總結

“釋放鎖”的過程相對“獲取鎖”的過程比較簡單。釋放鎖時，主要進行的操作，是更新當前線程對應的鎖的狀態。如果當前線程對鎖已經徹底釋放，則設置“鎖”的持有線程為null，設置當前線程的狀態為空，然後喚醒後繼線程。

參考：

http://www.cnblogs.com/skywang12345/p/3496609.html

Java多線程系列--“JUC鎖”04之 公平鎖(二)