ReentrantLock介紹
ReentrantLock重入鎖，是實現Lock接口的一個類，也是在實際編程中使用頻率很高的一個鎖，支持重入性，表示能夠對共享資源能夠重複加鎖，即當前線程獲取該鎖再次獲取不會被阻塞。
java關鍵字synchronized隱式支持重入性，synchronized通過獲取自增，釋放自減的方式實現重入。與此同時，ReentrantLock還支持公平鎖和非公平鎖兩種方式。
重入性的實現原理
要想支持重入性，就要解決兩個問題：
- 在線程獲取鎖的時候，如果已經獲取鎖的線程是當前線程的話則直接再次獲取成功；
- 由於鎖會被獲取n次，那麼只有鎖在被釋放同樣的n次之後，該鎖纔算是完全釋放成功。
通過之前文章對 AQS的分析，我們知道，同步組件主要是通過重寫AQS的幾個protected方法來表達自己的同步語義。針對第一個問題，我們來看看ReentrantLock是怎樣實現的，以非公平鎖爲例，判斷當前線程能否獲得鎖爲例，核心方法爲 nonfairTryAcquire()
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
/**
* Performs non-fair tryLock. tryAcquire is implemented in
* subclasses, but both need nonfair try for trylock method.
*/
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.再次獲取，計數+1
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時，鎖成功釋放，返回false
free = true;
setExclusiveOwnerThread(null);
}
// 3.鎖未被完全釋放，返回false
setState(c);
return free;
}
重入鎖的釋放必須得等到同步狀態爲0時鎖纔算成功釋放，否則鎖仍未釋放。如果鎖被獲取n次，釋放了n-1次，該鎖未完全釋放返回false，只有被釋放n次纔算成功釋放，返回true。
公平鎖與非公平鎖
ReentrantLock支持兩種鎖：公平鎖和非公平鎖。何謂公平性，是針對獲取鎖而言的，如果一個鎖是公平的，那麼鎖的獲取順序就應該符合請求上的絕對時間順序，滿足FIFO。ReentrantLock的構造方法無參時是構造非公平鎖，源碼爲：
/**
* Creates an instance of {@code ReentrantLock}.
* This is equivalent to using {@code ReentrantLock(false)}.
*/
public ReentrantLock() {
sync = new NonfairSync();
}
另外還提供了另外一種方式，可傳入一個boolean值，true時爲公平鎖，false時爲非公平鎖，源碼爲：
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
在上面非公平鎖獲取時（nonfairTryAcquire()方法）只是簡單的獲取了一下當前狀態做了一些邏輯處理，並沒有考慮到當前同步隊列中線程等待的情況。我們來看看公平鎖的處理邏輯是怎樣的，核心方法爲：
/**
* Sync object for fair locks
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
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()) {
// 再次獲取，計數+1
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
這段代碼的邏輯與nonfairTryAcquire()基本上一致，唯一的不同在於增加了hasQueuedPredecessors()的邏輯判斷，方法名就可知道該方法用來判斷當前節點在同步隊列中是否有前驅節點的判斷，如果有前驅節點說明有線程比當前線程更早的請求資源，根據公平性，當前線程請求資源失敗。如果當前節點沒有前驅節點的話，再纔有做後面的邏輯判斷的必要性。
公平鎖每次都是從同步隊列中的第一個節點獲取到鎖，而非公平性鎖則不一定，有可能剛釋放鎖的線程能再次獲取到鎖。
公平鎖 VS 非公平鎖
- 公平鎖每次獲取到鎖爲同步隊列中的第一個節點，保證請求資源時間上的絕對順序，而非公平鎖有可能剛釋放鎖的線程下次繼續獲取該鎖，則有可能導致其他線程永遠無法獲取到鎖，造成“飢餓”現象。
- 公平鎖爲了保證時間上的絕對順序，需要頻繁的上下文切換，而非公平鎖會降低一定的上下文切換，降低性能開銷。因此，
ReentrantLock()默認選擇的是非公平鎖，則是爲了減少一部分上下文切換，保證了系統更大的吞吐量。