完全理解ReentrantLock

1. ReentrantLock的介紹

ReentrantLock重入鎖，是實現Lock接口的一個類，也是在實際編程中使用頻率很高的一個鎖，支持重入性，表示可以對共享資源可以重複加鎖，即當前線程獲取該鎖再次獲取不會被阻塞。在java關鍵字synchronized隱式支持重入性（關於synchronized能夠看這篇文章），synchronized經過獲取自增，釋放自減的方式實現重入。與此同時，ReentrantLock還支持公平鎖和非公平鎖兩種方式。那麼，要想完徹底全的弄懂ReentrantLock的話，主要也就是ReentrantLock同步語義的學習：1. 重入性的實現原理；2. 公平鎖和非公平鎖。

2. 重入性的實現原理

要想支持重入性，就要解決兩個問題：**1. 在線程獲取鎖的時候，若是已經獲取鎖的線程是當前線程的話則直接再次獲取成功；2. 因爲鎖會被獲取n次，那麼只有鎖在被釋放一樣的n次以後，該鎖纔算是徹底釋放成功。**經過這篇文章，咱們知道，同步組件主要是經過重寫AQS的幾個protected方法來表達本身的同步語義。針對第一個問題，咱們來看看ReentrantLock是怎樣實現的，以非公平鎖爲例，判斷當前線程可否得到鎖爲例，核心方法爲nonfairTryAcquire：

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    //1. 若是該鎖未被任何線程佔有，該鎖能被當前線程獲取
	if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
	//2.若被佔有，檢查佔有線程是不是當前線程
    else if (current == getExclusiveOwnerThread()) {
		// 3. 再次獲取，計數加一
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
複製代碼

這段代碼的邏輯也很簡單，具體請看註釋。爲了支持重入性，在第二步增長了處理邏輯，若是該鎖已經被線程所佔有了，會繼續檢查佔有線程是否爲當前線程，若是是的話，同步狀態加1返回true，表示能夠再次獲取成功。每次從新獲取都會對同步狀態進行加一的操做，那麼釋放的時候處理思路是怎樣的了？（依然仍是以非公平鎖爲例）核心方法爲tryRelease：

protected final boolean tryRelease(int releases) {
	//1. 同步狀態減1
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
		//2. 只有當同步狀態爲0時，鎖成功被釋放，返回true
        free = true;
        setExclusiveOwnerThread(null);
    }
	// 3. 鎖未被徹底釋放，返回false
    setState(c);
    return free;
}
複製代碼

代碼的邏輯請看註釋，須要注意的是，重入鎖的釋放必須得等到同步狀態爲0時鎖纔算成功釋放，不然鎖仍未釋放。若是鎖被獲取n次，釋放了n-1次，該鎖未徹底釋放返回false，只有被釋放n次纔算成功釋放，返回true。到如今咱們能夠理清ReentrantLock重入性的實現了，也就是理解了同步語義的第一條。

3. 公平鎖與公平鎖

ReentrantLock支持兩種鎖：公平鎖和非公平鎖。何謂公平性，是針對獲取鎖而言的，若是一個鎖是公平的，那麼鎖的獲取順序就應該符合請求上的絕對時間順序，知足FIFO。ReentrantLock的構造方法無參時是構造非公平鎖，源碼爲：

public ReentrantLock() {
    sync = new NonfairSync();
}
複製代碼

另外還提供了另一種方式，可傳入一個boolean值，true時爲公平鎖，false時爲非公平鎖，源碼爲：

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}
複製代碼

在上面非公平鎖獲取時（nonfairTryAcquire方法）只是簡單的獲取了一下當前狀態作了一些邏輯處理，並無考慮到當前同步隊列中線程等待的狀況。咱們來看看公平鎖的處理邏輯是怎樣的，核心方法爲：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
  }
}
複製代碼

這段代碼的邏輯與nonfairTryAcquire基本上一直，惟一的不一樣在於增長了hasQueuedPredecessors的邏輯判斷，方法名就可知道該方法用來判斷當前節點在同步隊列中是否有前驅節點的判斷，若是有前驅節點說明有線程比當前線程更早的請求資源，根據公平性，當前線程請求資源失敗。若是當前節點沒有前驅節點的話，再纔有作後面的邏輯判斷的必要性。公平鎖每次都是從同步隊列中的第一個節點獲取到鎖，而非公平性鎖則不必定，有可能剛釋放鎖的線程能再次獲取到鎖。

公平鎖 VS 非公平鎖

1. 公平鎖每次獲取到鎖爲同步隊列中的第一個節點，保證請求資源時間上的絕對順序，而非公平鎖有可能剛釋放鎖的線程下次繼續獲取該鎖，則有可能致使其餘線程永遠沒法獲取到鎖，形成「飢餓」現象。

2. 公平鎖爲了保證時間上的絕對順序，須要頻繁的上下文切換，而非公平鎖會下降必定的上下文切換，下降性能開銷。所以，ReentrantLock默認選擇的是非公平鎖，則是爲了減小一部分上下文切換，保證了系統更大的吞吐量。

參考文獻

《java併發編程的藝術》