ReentrantLock不但是可重入鎖，而且還是公平或非公平鎖，在工作中會經常使用到，將自己對這兩種鎖的理解記錄下來，希望對大家有幫助。
前提條件
在理解ReentrantLock時需要具備一些基本的知識
理解AQS的實現原理
之前有寫過一篇《深入淺出AQS原始碼解析》關於AQS的文章，對AQS原理不瞭解的同學可以先看一下
什麼是可重入鎖
當一個執行緒已經持有鎖，如果該現在再次獲取鎖，是否可以獲取成功？如果能獲取成功則說明該鎖是可重入的，否則是不可重入的
什麼是公平鎖和非公平鎖
公平與非公平的一個很本質的區別就是，是否遵守FIFO（也就是先來後到）。當有多個執行緒來申請鎖的時候，是否先申請的執行緒先獲取鎖，後申請的執行緒後獲取鎖？如果是的，則是公平鎖，否則是非公平鎖。
更準確地說，先申請鎖的執行緒先獲得鎖競爭的權利。對於公平的排他鎖而言，先申請鎖的執行緒會先獲取鎖，但是對於公平的共享鎖而言，先申請鎖的執行緒會先擁有獲取鎖競爭的權利，其他等待共享鎖的執行緒也會被喚醒，有可能後喚醒的執行緒先獲取鎖。
ReentrantLock 原始碼解析
ReentrantLock的功能主要是通過3個內部類Sync、FairSync和NonfairSync來實現的，這3個內部類繼承了AbstractQueuedSynchronizer，其中FairSync和NonfairSync類繼承了Sync，接下來我們一一解讀這幾個內部類。
ReentrantLock.Sync類原始碼解析
由於ReentrantLock.Sync類中的核心程式碼比較少，原理也比較簡單，所以就直接在程式碼中通過詳細註釋的方式來解讀
abstract static class Sync extends AbstractQueuedSynchronizer {
/**
* 定義了一個抽象方法，用來獲取鎖
*/
abstract void lock();
/**
* NonfairSync中tryAcquire和、ReentrantLock.tryLock會使用到
* 重要功能：快速嘗試獲取鎖，如果能夠獲取鎖返回true，否則返回false
* 在嘗試獲取鎖的過程中，不會阻塞當前執行緒，一般情況下是當前執行緒已經持有鎖時
* 才有可能是可以直接獲取鎖，這也是可重入功能的核心實現
*/
final boolean nonfairTryAcquire(int acquires) {
// 獲取當前執行緒
final Thread current = Thread.currentThread();
/**
* state是AQS對外提供的一個變數，讓不同的實現類可以通過這個變數
* 來控制鎖被執行緒獲取鎖的次數
*/
int c = getState();
// 當state為0表示該鎖是沒有被任何執行緒持有
if (c == 0) {
/**
* CAS操作如果成功，說明當前執行緒競爭到了鎖資源，
* 否則被其他執行緒競爭到了，當前執行緒需要進入AQS的同步佇列
* 對於嘗試修改state的值的執行緒可以同時是多個，
* 他們之間沒有先後順序，這也是非公平的重要體現
*/
if (compareAndSetState(0, acquires)) {
/**
* 當前執行緒已經持有鎖了，設定鎖的佔有者
*/
setExclusiveOwnerThread(current);
return true;
}
}
/**
* 如果持有鎖的執行緒是當前執行緒，可以繼續嘗試獲取鎖
* 這也是可重入的重要體現
*/
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
/**
* state是int型別，也就是可重入次數不能低於Integer.MAX_VALUE
*/
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
/**
* 獲取鎖以後直接設定state的值
*/
setState(nextc);
return true;
}
/**
* 如果一個執行緒既不是第一次獲取鎖，又不是已經獲取鎖，
* 則該執行緒無法獲取鎖，需要進入AQS的同步佇列排隊
*/
return false;
}
protected final boolean tryRelease(int releases) {
/**
* 計算釋放releases個資源後state的值
*/
int c = getState() - releases;
/**
* 持有鎖的執行緒如果不是當前執行緒，無法釋放資源
*/
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
/**
* 當所有的資源全部釋放掉（c=0）時，鎖的持有者需要設定為null，
* 讓後續執行緒可以來競爭鎖
*/
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
/**
* 修改state的狀態
*/
setState(c);
return free;
}
protected final boolean isHeldExclusively() {
/**
* 當前執行緒是否持有鎖
*/
return getExclusiveOwnerThread() == Thread.currentThread();
}
ReentrantLock.NonfairSync類原始碼解析
static final class NonfairSync extends Sync {
/**
* 非公平鎖，對外獲取鎖的步驟：
* 首先，嘗試修改state的狀態（從0修改成1），如果修改成功說明當前沒有任何執行緒持有鎖
* 如果執行緒獲取到鎖，則把鎖的持有執行緒設定為當前執行緒
* 如果無法獲取鎖，說明鎖已經被執行緒持有，有兩種情況：
* 情況1：持有鎖的執行緒是當前執行緒，可以走可重入的流程
* 情況2：持有鎖的執行緒不是當前執行緒，需要進入AQS去排隊
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
/**
* 嘗試快速獲取鎖
*/
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
ReentrantLock.FairSync類原始碼解析
static final class FairSync extends Sync {
/**
* 阻塞方式獲取鎖
*/
final void lock() {
acquire(1);
}
/**
* 嘗試獲取公平鎖，與上面分析的nonfairTryAcquire方法很類似，
* 重點描述彼此之間的區別
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
/**
* 公平鎖與非公平鎖很大的一個區別是：
* 在嘗試獲取鎖的時候，如果AQS的同步佇列中有其他執行緒在等待獲取鎖
* 則嘗試獲取鎖失敗，需要進入AQS的同步佇列排隊
* hasQueuedPredecessors方法判斷AQS的同步佇列是否有執行緒在等待
*/
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;
}
}
ReentrantLock類原始碼解析
ReentrantLock類的實現方式比較簡單，主要是依靠NonfairSync和FairSync實現的功能
public class ReentrantLock implements Lock, java.io.Serializable {
private final Sync sync;
/**
* 預設是非公平鎖
*/
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* 獲取鎖，獲取的時候申請1個資源
*/
public void lock() {
sync.lock();
}
/**
* 可中斷的方式獲取鎖
*/
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
/**
*
* 嘗試獲取鎖，公平鎖和非公平鎖都是直接去嘗試獲取鎖
* 一般在使用該方法的時候，如果嘗試獲取鎖失敗，會有後續操作，
* 可能是直接呼叫lock以阻塞的方式來獲取鎖
*/
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
/**
* 帶有超時時間的方式嘗試獲取鎖
*/
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
/**
* 釋放鎖，釋放掉1個資源
*/
public void unlock() {
sync.release(1);
}
}
小結
- 對於已經持有鎖的執行緒，優先申請到資源
- 對與沒有持有鎖的執行緒，需要等待持有鎖的執行緒釋放掉所有資源，包括可重入時申請到的資源
- 公平鎖在申請資源的時候要先檢查AQS同步佇列中是否有等待的執行緒，也就執行緒獲取鎖是按照FIFO的方式