保證線程安全的方式有很多，比如CAS操作、synchronized、原子類、volatile保證可見性和ReentrantLock等，這篇文章我們主要探討ReentrantLock的相關內容。本文基于JDK1.8講述ReentrantLock.
一、可重入鎖
所謂可重入鎖，即一個線程已經(jīng)獲得了某個鎖，當這個線程要再次獲取這個鎖時，依然可以獲取成功，不會發(fā)生死鎖的情況。synchronized就是一個可重入鎖，除此之外，JDK提供的ReentrantLock也是一種可重入鎖。
二、ReentrantLock
2.1 ReentrantLock的簡單使用
public class TestReentrantLock {
private static int i = 0;
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
try {
lock.lock();
i++;
} finally {
lock.unlock();
}
System.out.println(i);
}
}
上面是ReentrantLock的一個簡單使用案列，進入同步代碼塊之前，需要調用lock()方法進行加鎖，執(zhí)行完同步代碼塊之后，為了防止異常發(fā)生時造成死鎖，需要在finally塊中調用unlock()方法進行解鎖。
2.2 ReentrantLock UML圖
2.3 lock()方法調用鏈
上圖描述了ReentrantLock.lock()加鎖的方法調用過程。在ReentrantLock中有一個成員變量private final Sync sync，Sync是AQS的一個子類。ReentrantLock的lock()方法中，調用了sync的lock()方法，這個方法為抽象方法，具體調用的是NonfairSync中實現(xiàn)的lock()方法：
/**
* 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);
}
在這個方法中，先嘗試通過CAS操作進行加鎖。如果加鎖失敗，會調用AQS的acquire()方法：
/**
* Acquires in exclusive mode, ignoring interrupts. Implemented
* by invoking at least once {@link #tryAcquire},
* returning on success. Otherwise the thread is queued, possibly
* repeatedly blocking and unblocking, invoking {@link
* #tryAcquire} until success. This method can be used
* to implement method {@link Lock#lock}.
*
* @param arg the acquire argument. This value is conveyed to
* {@link #tryAcquire} but is otherwise uninterpreted and
* can represent anything you like.
*/
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
在AQS的acquire方法中，先嘗試調用tryAcquire方法進行加鎖，如果失敗，會調用acquireQueued進入等待隊列當中。acquireQueued方法將會在第三章中講解，先來看tryAcquire方法的內容。AQS的tryAcquire方法是一個模板方法，其具體實現(xiàn)在NonfairSync的tryAcquire方法中，里面僅僅是調用了nonfairTryAcquire方法：
/**
* 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();
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;
}
在這個方法中，先獲取state判斷其是否為0。如果為0表示沒有其他線程占用鎖，會嘗試通過CAS操作將state設為1進行加鎖；如果state不為0，表示某個線程已經(jīng)占用了鎖，判斷占用鎖的線程是否為當前線程，如果是，則將state進行加1的操作，這就是ReentrantLock可重入的實現(xiàn)原理。
三、AQS
AQS即AbstractQueuedSynchronizer。AQS提供了一個基于FIFO隊列，可以用于構建鎖或者其他相關同步裝置的基礎框架。AQS其實是CLH(Craig，Landin，Hagersten)鎖的一個變種，下面來講解AQS的核心思想及其具體實現(xiàn)。
3.1 state
/**
* The synchronization state.
*/
private volatile int state;state是AQS中最核心的成員變量。這是一個volatile變量，當其為0時，表示沒有任何線程占用鎖。線程通過CAS將state從0置為1進行加鎖，當線程持有鎖的情況下，再次進行加鎖，會將state加1，即重入。
3.2 exclusiveOwnerThread
/**
* The current owner of exclusive mode synchronization.
*/
private transient Thread exclusiveOwnerThread;exclusiveOwnerThread是AQS的父類AbstractOwnableSynchronizer中的成員變量，其作用是實現(xiàn)可重入機制時，用于判斷持有鎖的線程是否為當前線程。
3.3 AQS等待隊列
除了以上state和exclusiveOwnerThread兩個重要的成員變量以外，AQS還維護了一個等待隊列。當線程嘗試加鎖失敗時，會進入這個等待隊列中，這也是整個AQS中最核心的內容。這個等待隊列是一個雙向鏈表，其節(jié)點Node對等待加鎖的線程進行封裝。
/**
* Creates and enqueues node for current thread and given mode.
*
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* @return the new node
*/
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
// 通過CAS操作將自身追加到鏈表尾部
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
當線程嘗試加鎖失敗時，通過CAS操作將自身追加到鏈表尾部。入隊之后，會調用acquireQueued在隊列中嘗試加鎖：
/**
* Acquires in exclusive uninterruptible mode for thread already in
* queue. Used by condition wait methods as well as acquire.
*
* @param node the node
* @param arg the acquire argument
* @return {@code true} if interrupted while waiting
*/
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
在這個方法中，會判斷其前置節(jié)點是否為頭節(jié)點，如果是，則嘗試進行加鎖。如果加鎖失敗，則調用LockSupport.park方法進入阻塞狀態(tài)，等待其前置節(jié)點釋放鎖之后將其喚醒。
3.4 AQS中的模板方法設計模式
AQS完美地運用了模板方法設計模式，其中定義了一系列的模板方法。比如以下方法：
// 互斥模式下使用：嘗試獲取鎖
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
// 互斥模式下使用：嘗試釋放鎖
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
// 共享模式下使用：嘗試獲取鎖
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
// 共享模式下使用：嘗試釋放鎖
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
這些方法在AQS中只拋出了UnsupportedOperationException異常，所以需要子類去實現(xiàn)它們。之所以沒有將這些方法設計成為抽象方法，是因為AQS的子類可能只需要實現(xiàn)其中的某些方法即可實現(xiàn)其功能。
總結
不同版本的JDK，AQS的實現(xiàn)可能會有細微的差異，但其核心思想是不會變的，即線程加鎖失敗后，通過CAS進行入隊的操作，并通過CAS的方法設置state來獲得鎖。
到這里，本篇關于Java多線程中的可重入鎖ReentrantLock詳細講解的文章就到此結束了，如果您還想要了解更多關于Java多線程相關知識，推薦您可以看一看我們的Java多線程視頻，適合想要了解Java多線程的小伙伴們。
