ReentrantLock 重入鎖實現(xiàn)了 Lock和 java.io.Serializable接口，并提供了與synchronized相同的互斥性和內(nèi)存可見性，ReentrantLock 提供了可重入的加鎖語義，能夠?qū)蚕碣Y源能夠重復加鎖，即當前線程獲取該鎖再次獲取不會被阻塞。
可重入性：重入性是指任意線程在獲取到鎖之后能夠再次獲取該鎖而不會被鎖阻塞。所需要去識別獲取鎖的線程是否為當前占據(jù)鎖的線程，如果是，則再次獲取成功。鎖的最終釋放：線程重復n次獲取了鎖，隨后在第n次釋放該鎖后，其它線程能夠獲取到該鎖。鎖的最終釋放要求鎖對于獲取進行計數(shù)自增，計數(shù)表示當前線程被重復獲取的次數(shù)，而被釋放時，計數(shù)自減，當計數(shù)為0時表示鎖已經(jīng)成功釋放。
ReentrantLock實現(xiàn)了 Lock和 Serializable接口，內(nèi)部有三個內(nèi)部類，Sync、NonfairSync、FairSync。
Sync 是一個抽象類型，它繼承 AbstractQueuedSynchronizer，這個AbstractQueuedSynchronizer是一個模板類，它實現(xiàn)了許多和鎖相關的功能，并提供了鉤子方法供用戶實現(xiàn)，比如 tryAcquire、tryRelease 等。Sync實現(xiàn)了AbstractQueuedSynchronizer的tryRelease方法。
NonfairSync和FairSync兩個類繼承自Sync，實現(xiàn)了lock方法，然后分別公平搶占和非公平搶占針對tryAcquire有不同的實現(xiàn)。
ReentrantLock的底層原理主要基于CAS（Compare and Swap，比較并交換）和AQS（AbstractQueuedSynchronizer，抽象隊列同步器）實現(xiàn)。支持公平鎖和非公平鎖兩種模式，默認采用非公平鎖。
公平鎖：公平鎖確保線程按照請求鎖的順序來獲取鎖，先到達的線程將先獲得鎖，這有助于避免線程饑餓，即一個線程可能因為等待其他線程釋放鎖而長時間無法獲得鎖。
非公平鎖：非公平鎖允許新線程插隊搶占鎖，這可能導致某些線程等待較長時間才能獲得鎖，非公平鎖的主要優(yōu)勢在于減少了線程上下文切換的開銷，從而提高了整體的吞吐效率，但缺點是可能導致某些線程等待時間較長。
線程A、B、C在競爭鎖的流程圖-非公平鎖
創(chuàng)建鎖
// 默認是非公平鎖
ReentrantLock lock = new ReentrantLock();
線程A執(zhí)行業(yè)務加鎖調(diào)用lock.lock()，state為0，CAS修改state=1，獲取到了鎖；
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
線程B調(diào)用lock.lock()，返回false，進入else方法acquire(1)，執(zhí)行tryAcquire，最終執(zhí)行nonfairTryAcquire，也返回false
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 獲取鎖成功，設置為當前線程所有
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 線程重入
// 判斷鎖持有的線程是否為當前線程
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
線程B加入隊列等待
addWaiter(Node.EXCLUSIVE), arg)
線程A解鎖
public void unlock() {
sync.release(1);
}
如果tryRelease方法返回true，等待隊列中的頭結(jié)點被喚醒
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head
// h.waitStatus!=0 說明前驅(qū)結(jié)點處于SIGNAL狀態(tài)，表示下一個線程在等待其喚醒
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
設置 state = 0
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
// 通過判斷當前線程是否為獲得到鎖的線程，保證該方法線程安全
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 只有當同步狀態(tài)徹底釋放后，該方法才會返回 true 。當 state == 0 時，則將鎖持有線程設置為 null ，free= true，表示釋放成功。
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
喚醒等待的頭節(jié)點線程B
private void unparkSuccessor(Node node) {
// 前驅(qū)結(jié)點 waitStatus = -1
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
// 從后往前找到離head最近，而且waitStatus <= 0 的節(jié)點
if (t.waitStatus <= 0)
s = t;
}
// 喚醒線程
if (s != null)
LockSupport.unpark(s.thread);
}
線程B被喚醒后tryAcquire方法競爭鎖
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor(); // 獲得 node 前驅(qū)節(jié)點
if (p == head && tryAcquire(arg)) { // 如果 node 前驅(qū)節(jié)點是 head，再次嘗試拿鎖，調(diào)用 tryAcquire；
// 如果拿到鎖，這里就是雙向鏈表中的操作，head 節(jié)點出隊
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) && // 獲取鎖失敗，考慮是否要阻塞該線程
parkAndCheckInterrupt()) // 阻塞線程
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
同時線程C調(diào)用lock. lock()方法，最終，C線程CAS操作搶先拿到了鎖，B線程獲取鎖失敗，繼續(xù)被阻塞等待鎖；
線程A、B、C在競爭鎖的流程圖-公平鎖
代碼不同點，lock()方法，沒有CAS插隊獲取鎖
final void lock() {
acquire(1);
}
多了一個hasQueuedPredecessors()，該方法名稱是：是否擁有前一個隊列元素，換言之：用不用排隊。返回false:不用排隊，返回true:需要排隊。
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;
}
public final boolean hasQueuedPredecessors() {
Node t = tail; //尾節(jié)點
Node h = head; //頭節(jié)點
Node s;
// 1.頭節(jié)點 != 尾節(jié)點 &&
// 2.同步隊列第一個節(jié)點不為null || 3.當前線程是同步隊列第一個節(jié)點
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
如果和上面流程一樣情況下，線程C嘗試獲取鎖，返回true，需要排隊，而線程B在隊首，會先試用鎖。
公平鎖和非公平鎖的區(qū)別
鎖的公平性是相對于獲取鎖的順序而言的。
如果是一個公平鎖，那么鎖的獲取順序就應該符合請求的絕對時間順序，也就是FIFO，線程獲取鎖的順序和調(diào)用lock的順序一樣，能夠保證老的線程排隊使用鎖，新線程仍然排隊使用鎖。
非公平鎖只要CAS設置同步狀態(tài)成功，則表示當前線程獲取了鎖，線程獲取鎖的順序和調(diào)用lock的順序無關，全憑運氣，也就是老的線程排隊使用鎖，但是無法保證新線程搶占已經(jīng)在排隊的線程的鎖。
ReentrantLock默認使用非公平鎖是基于性能考慮，公平鎖為了保證線程規(guī)規(guī)矩矩地排隊，需要增加阻塞和喚醒的時間開銷。如果直接插隊獲取非公平鎖，跳過了對隊列的處理，速度會更快。
