深入淺出ReentrantLock源碼解析
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的方式