這篇文章帶給大家的內容是關於ReentrantLock的實現原理介紹（程式碼範例），有一定的參考價值，有需要的朋友可以參考一下，希望對你有幫助。
在並發程式設計中，除了synchronized關鍵字，java並發套件中java.util.concurrent.locks中的ReentrantLock和ReentrantReadWriteLock也是常用的鎖定實作。本篇從原始碼方面，分析一下重入鎖ReentrantLock的原理。
先說一下什麼的重入鎖：某個執行緒取得鎖以後，還可以多次重複取得鎖，不會自己阻塞自己。
ReentrantLock是基於抽象類別AbstractQueuedSynchronizer（以下簡稱AQS）實作。
看原始碼：
首先從建構器可以看出，ReentrantLock有公平鎖和非公平鎖兩種機制。
//默认非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}先簡單說明公平鎖定和非公平鎖定的區別，然後在分析兩者的不同實現方式。
公平鎖定：多個執行緒之間講究先來後到。類似排隊，後面來的線程依序排在佇列最後。
非公平鎖定：進行鎖的爭搶。搶到就執行，沒搶到就阻塞。等待獲得鎖的線程釋放後，再參與競爭。
所以通常使用非公平鎖。其效率比公平鎖高。
取得鎖定
公平鎖定
#final void lock() {
acquire(1);
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}第一步tryAcquire(arg)嘗試加入鎖，由FairSync實現，具體程式碼如下：
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;
}#取得目前執行緒
取得AQS中的state。如果state為0，表示此時沒有執行緒獲得鎖。
在if判斷中，先判斷AQS的Node佇列是否為空。如果不是空的，就需要排隊。此時不取得鎖。
嘗試使用CAS演算法，將state更新為1。更新成功，取得鎖，將此時的執行緒設定為獨佔執行緒exclusiveOwnerThread。傳回true。
如果state不為0，表示已經有執行緒獲得了鎖定。所以要判斷獲得鎖的線程（獨佔線程）是否為當前線程。
如果是，表示是重入情況。將state增加1。傳回true。
走到最後一步，就是沒有獲得鎖定了。傳回false；
繼續上面的步驟，如果取得鎖定失敗，先執行addWaiter(Node.EXCLUSIVE)，將目前執行緒寫入佇列
#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;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}封裝一個新節點node
#判斷鍊錶尾是否為空，不是就把新節點node'寫入最後
'鍊錶尾為空，則以enq(node)寫入最後。
寫入佇列以後，acquireQueued()方法，掛起目前執行緒。
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);
}
}在循環中，如果node的上一個是頭節點，則再嘗試取得鎖定。成功就結束循環，回傳false
不是頭節點，就根據上一個節點的waitStatus，判斷是否需要掛起目前執行緒。 waitStatus用來記錄節點狀態，如節點取消，節點等待等。
判斷需要掛起，則使用parkAndCheckInterrupt()方法，並掛起執行緒。具體使用LockSupport.park(this)掛起執行緒。
如果在這裡的第一步就取得鎖定成功了，就可以取消此節點的取得鎖定操作了。
非公平鎖定
非公平鎖定在鎖的取得策略上有差異。
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}非公平鎖定先直接嘗試使用CAS演算法更新state，取得鎖定
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;
}釋放鎖定
公平鎖定和非公平鎖定釋放鎖定的步驟都一樣public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
//更新state
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}以上是ReentrantLock的實作原理介紹（程式碼範例）的詳細內容。更多資訊請關注PHP中文網其他相關文章！
