溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
問題
（1）重入鎖是什么？
（2）ReentrantLock如何實現(xiàn)重入鎖？
（3）ReentrantLock為什么默認是非公平模式？
（4）ReentrantLock除了可重入還有哪些特性？
簡介
Reentrant = Re + entrant，Re是重復、又、再的意思，entrant是enter的名詞或者形容詞形式，翻譯為進入者或者可進入的，所以Reentrant翻譯為可重復進入的、可再次進入的，因此ReentrantLock翻譯為重入鎖或者再入鎖。
重入鎖，是指一個線程獲取鎖之后再嘗試獲取鎖時會自動獲取鎖。
在Java中，除了ReentrantLock以外，synchronized也是重入鎖。
那么，ReentrantLock的可重入性是怎么實現(xiàn)的呢？
繼承體系
ReentrantLock實現(xiàn)了Lock接口，Lock接口里面定義了java中鎖應該實現(xiàn)的幾個方法：
// 獲取鎖 void lock(); // 獲取鎖（可中斷） void lockInterruptibly() throws InterruptedException; // 嘗試獲取鎖，如果沒獲取到鎖，就返回false boolean tryLock(); // 嘗試獲取鎖，如果沒獲取到鎖，就等待一段時間，這段時間內(nèi)還沒獲取到鎖就返回false boolean tryLock(long time, TimeUnit unit) throws InterruptedException; // 釋放鎖 void unlock(); // 條件鎖 Condition newCondition();
Lock接口中主要定義了 獲取鎖、嘗試獲取鎖、釋放鎖、條件鎖等幾個方法。
源碼分析
主要內(nèi)部類
ReentrantLock中主要定義了三個內(nèi)部類：Sync、NonfairSync、FairSync。
abstract static class Sync extends AbstractQueuedSynchronizer {}
static final class NonfairSync extends Sync {}
static final class FairSync extends Sync {}
（1）抽象類Sync實現(xiàn)了AQS的部分方法；
（2）NonfairSync實現(xiàn)了Sync，主要用于非公平鎖的獲??；
（3）FairSync實現(xiàn)了Sync，主要用于公平鎖的獲取。
在這里我們先不急著看每個類具體的代碼，等下面學習具體的功能點的時候再把所有方法串起來。
主要屬性
private final Sync sync;
主要屬性就一個sync，它在構(gòu)造方法中初始化，決定使用公平鎖還是非公平鎖的方式獲取鎖。
主要構(gòu)造方法
// 默認構(gòu)造方法
public ReentrantLock() {
sync = new NonfairSync();
}
// 自己可選擇使用公平鎖還是非公平鎖
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
（1）默認構(gòu)造方法使用的是非公平鎖；
（2）第二個構(gòu)造方法可以自己決定使用公平鎖還是非公平鎖；
上面我們分析了ReentrantLock的主要結(jié)構(gòu)，下面我們跟著幾個主要方法來看源碼。
lock()方法
彤哥貼心地在每個方法的注釋都加上方法的來源。
1.公平鎖
這里我們假設ReentrantLock的實例是通過以下方式獲得的：
ReentrantLock reentrantLock = new ReentrantLock(true);
下面的是加鎖的主要邏輯：
// ReentrantLock.lock()
public void lock() {
// 調(diào)用的sync屬性的lock()方法
// 這里的sync是公平鎖，所以是FairSync的實例
sync.lock();
}
// ReentrantLock.FairSync.lock()
final void lock() {
// 調(diào)用AQS的acquire()方法獲取鎖
// 注意，這里傳的值為1
acquire(1);
}
// AbstractQueuedSynchronizer.acquire()
public final void acquire(int arg) {
// 嘗試獲取鎖
// 如果失敗了，就排隊
if (!tryAcquire(arg) &&
// 注意addWaiter()這里傳入的節(jié)點模式為獨占模式
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// ReentrantLock.FairSync.tryAcquire()
protected final boolean tryAcquire(int acquires) {
// 當前線程
final Thread current = Thread.currentThread();
// 查看當前狀態(tài)變量的值
int c = getState();
// 如果狀態(tài)變量的值為0，說明暫時還沒有人占有鎖
if (c == 0) {
// 如果沒有其它線程在排隊，那么當前線程嘗試更新state的值為1
// 如果成功了，則說明當前線程獲取了鎖
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
// 當前線程獲取了鎖，把自己設置到exclusiveOwnerThread變量中
// exclusiveOwnerThread是AQS的父類AbstractOwnableSynchronizer中提供的變量
setExclusiveOwnerThread(current);
// 返回true說明成功獲取了鎖
return true;
}
}
// 如果當前線程本身就占有著鎖，現(xiàn)在又嘗試獲取鎖
// 那么，直接讓它獲取鎖并返回true
else if (current == getExclusiveOwnerThread()) {
// 狀態(tài)變量state的值加1
int nextc = c + acquires;
// 如果溢出了，則報錯
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
// 設置到state中
// 這里不需要CAS更新state
// 因為當前線程占有著鎖，其它線程只會CAS把state從0更新成1，是不會成功的
// 所以不存在競爭，自然不需要使用CAS來更新
setState(nextc);
// 當線程獲取鎖成功
return true;
}
// 當前線程嘗試獲取鎖失敗
return false;
}
// AbstractQueuedSynchronizer.addWaiter()
// 調(diào)用這個方法，說明上面嘗試獲取鎖失敗了
private Node addWaiter(Node mode) {
// 新建一個節(jié)點
Node node = new Node(Thread.currentThread(), mode);
// 這里先嘗試把新節(jié)點加到尾節(jié)點后面
// 如果成功了就返回新節(jié)點
// 如果沒成功再調(diào)用enq()方法不斷嘗試
Node pred = tail;
// 如果尾節(jié)點不為空
if (pred != null) {
// 設置新節(jié)點的前置節(jié)點為現(xiàn)在的尾節(jié)點
node.prev = pred;
// CAS更新尾節(jié)點為新節(jié)點
if (compareAndSetTail(pred, node)) {
// 如果成功了，把舊尾節(jié)點的下一個節(jié)點指向新節(jié)點
pred.next = node;
// 并返回新節(jié)點
return node;
}
}
// 如果上面嘗試入隊新節(jié)點沒成功，調(diào)用enq()處理
enq(node);
return node;
}
// AbstractQueuedSynchronizer.enq()
private Node enq(final Node node) {
// 自旋，不斷嘗試
for (;;) {
Node t = tail;
// 如果尾節(jié)點為空，說明還未初始化
if (t == null) { // Must initialize
// 初始化頭節(jié)點和尾節(jié)點
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 如果尾節(jié)點不為空
// 設置新節(jié)點的前一個節(jié)點為現(xiàn)在的尾節(jié)點
node.prev = t;
// CAS更新尾節(jié)點為新節(jié)點
if (compareAndSetTail(t, node)) {
// 成功了，則設置舊尾節(jié)點的下一個節(jié)點為新節(jié)點
t.next = node;
// 并返回舊尾節(jié)點
return t;
}
}
}
}
// AbstractQueuedSynchronizer.acquireQueued()
// 調(diào)用上面的addWaiter()方法使得新節(jié)點已經(jīng)成功入隊了
// 這個方法是嘗試讓當前節(jié)點來獲取鎖的
final boolean acquireQueued(final Node node, int arg) {
// 失敗標記
boolean failed = true;
try {
// 中斷標記
boolean interrupted = false;
// 自旋
for (;;) {
// 當前節(jié)點的前一個節(jié)點
final Node p = node.predecessor();
// 如果當前節(jié)點的前一個節(jié)點為head節(jié)點，則說明輪到自己獲取鎖了
// 調(diào)用ReentrantLock.FairSync.tryAcquire()方法再次嘗試獲取鎖
if (p == head && tryAcquire(arg)) {
// 嘗試獲取鎖成功
// 這里同時只會有一個線程在執(zhí)行，所以不需要用CAS更新
// 把當前節(jié)點設置為新的頭節(jié)點
setHead(node);
// 并把上一個節(jié)點從鏈表中刪除
p.next = null; // help GC
// 未失敗
failed = false;
return interrupted;
}
// 是否需要阻塞
if (shouldParkAfterFailedAcquire(p, node) &&
// 真正阻塞的方法
parkAndCheckInterrupt())
// 如果中斷了
interrupted = true;
}
} finally {
// 如果失敗了
if (failed)
// 取消獲取鎖
cancelAcquire(node);
}
}
// AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire()
// 這個方法是在上面的for()循環(huán)里面調(diào)用的
// 第一次調(diào)用會把前一個節(jié)點的等待狀態(tài)設置為SIGNAL，并返回false
// 第二次調(diào)用才會返回true
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 上一個節(jié)點的等待狀態(tài)
// 注意Node的waitStatus字段我們在上面創(chuàng)建Node的時候并沒有指定
// 也就是說使用的是默認值0
// 這里把各種等待狀態(tài)再貼出來
//static final int CANCELLED = 1;
//static final int SIGNAL = -1;
//static final int CONDITION = -2;
//static final int PROPAGATE = -3;
int ws = pred.waitStatus;
// 如果等待狀態(tài)為SIGNAL(等待喚醒)，直接返回true
if (ws == Node.SIGNAL)
return true;
// 如果前一個節(jié)點的狀態(tài)大于0，也就是已取消狀態(tài)
if (ws > 0) {
// 把前面所有取消狀態(tài)的節(jié)點都從鏈表中刪除
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 如果前一個節(jié)點的狀態(tài)小于等于0，則把其狀態(tài)設置為等待喚醒
// 這里可以簡單地理解為把初始狀態(tài)0設置為SIGNAL
// CONDITION是條件鎖的時候使用的
// PROPAGATE是共享鎖使用的
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
// AbstractQueuedSynchronizer.parkAndCheckInterrupt()
private final boolean parkAndCheckInterrupt() {
// 阻塞當前線程
// 底層調(diào)用的是Unsafe的park()方法
LockSupport.park(this);
// 返回是否已中斷
return Thread.interrupted();
}
下面我們看一下主要方法的調(diào)用關系，可以跟著我的 → 層級在腦海中大概過一遍每個方法的主要代碼：
ReentrantLock#lock() ->ReentrantLock.FairSync#lock() // 公平模式獲取鎖 ->AbstractQueuedSynchronizer#acquire() // AQS的獲取鎖方法 ->ReentrantLock.FairSync#tryAcquire() // 嘗試獲取鎖 ->AbstractQueuedSynchronizer#addWaiter() // 添加到隊列 ->AbstractQueuedSynchronizer#enq() // 入隊 ->AbstractQueuedSynchronizer#acquireQueued() // 里面有個for()循環(huán)，喚醒后再次嘗試獲取鎖 ->AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire() // 檢查是否要阻塞 ->AbstractQueuedSynchronizer#parkAndCheckInterrupt() // 真正阻塞的地方
獲取鎖的主要過程大致如下：
（1）嘗試獲取鎖，如果獲取到了就直接返回了；
（2）嘗試獲取鎖失敗，再調(diào)用addWaiter()構(gòu)建新節(jié)點并把新節(jié)點入隊；
（3）然后調(diào)用acquireQueued()再次嘗試獲取鎖，如果成功了，直接返回；
（4）如果再次失敗，再調(diào)用shouldParkAfterFailedAcquire()將節(jié)點的等待狀態(tài)置為等待喚醒（SIGNAL）；
（5）調(diào)用parkAndCheckInterrupt()阻塞當前線程；
（6）如果被喚醒了，會繼續(xù)在acquireQueued()的for()循環(huán)再次嘗試獲取鎖，如果成功了就返回；
（7）如果不成功，再次阻塞，重復（3）（4）（5）直到成功獲取到鎖。
以上就是整個公平鎖獲取鎖的過程，下面我們看看非公平鎖是怎么獲取鎖的。
2.非公平鎖
// ReentrantLock.lock()
public void lock() {
sync.lock();
}
// ReentrantLock.NonfairSync.lock()
// 這個方法在公平鎖模式下是直接調(diào)用的acquire(1);
final void lock() {
// 直接嘗試CAS更新狀態(tài)變量
if (compareAndSetState(0, 1))
// 如果更新成功，說明獲取到鎖，把當前線程設為獨占線程
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
// ReentrantLock.NonfairSync.tryAcquire()
protected final boolean tryAcquire(int acquires) {
// 調(diào)用父類的方法
return nonfairTryAcquire(acquires);
}
// ReentrantLock.Sync.nonfairTryAcquire()
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 如果狀態(tài)變量的值為0，再次嘗試CAS更新狀態(tài)變量的值
// 相對于公平鎖模式少了!hasQueuedPredecessors()條件
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;
}
相對于公平鎖，非公平鎖加鎖的過程主要有兩點不同：
（1）一開始就嘗試CAS更新狀態(tài)變量state的值，如果成功了就獲取到鎖了；
（2）在tryAcquire()的時候沒有檢查是否前面有排隊的線程，直接上去獲取鎖才不管別人有沒有排隊呢；
總的來說，相對于公平鎖，非公平鎖在一開始就多了兩次直接嘗試獲取鎖的過程。
lockInterruptibly()方法
支持線程中斷，它與lock()方法的主要區(qū)別在于lockInterruptibly()獲取鎖的時候如果線程中斷了，會拋出一個異常，而lock()不會管線程是否中斷都會一直嘗試獲取鎖，獲取鎖之后把自己標記為已中斷，繼續(xù)執(zhí)行自己的邏輯，后面也會正常釋放鎖。
題外話：
線程中斷，只是在線程上打一個中斷標志，并不會對運行中的線程有什么影響，具體需要根據(jù)這個中斷標志干些什么，用戶自己去決定。
比如，如果用戶在調(diào)用lock()獲取鎖后，發(fā)現(xiàn)線程中斷了，就直接返回了，而導致沒有釋放鎖，這也是允許的，但是會導致這個鎖一直得不到釋放，就出現(xiàn)了死鎖。
lock.lock();
if (Thread.currentThread().interrupted()) {
return ;
}
lock.unlock();
當然，這里只是舉個例子，實際使用肯定是要把lock.lock()后面的代碼都放在try...finally...里面的以保證鎖始終會釋放，這里主要是為了說明線程中斷只是一個標志，至于要做什么完全由用戶自己決定。
tryLock()方法
嘗試獲取一次鎖，成功了就返回true，沒成功就返回false，不會繼續(xù)嘗試。
// ReentrantLock.tryLock()
public boolean tryLock() {
// 直接調(diào)用Sync的nonfairTryAcquire()方法
return sync.nonfairTryAcquire(1);
}
// ReentrantLock.Sync.nonfairTryAcquire()
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;
}
tryLock()方法比較簡單，直接以非公平的模式去嘗試獲取一次鎖，獲取到了或者鎖本來就是當前線程占有著就返回true，否則返回false。
tryLock(long time, TimeUnit unit)方法
嘗試獲取鎖，并等待一段時間，如果在這段時間內(nèi)都沒有獲取到鎖，就返回false。
// ReentrantLock.tryLock()
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
// 調(diào)用AQS中的方法
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
// AbstractQueuedSynchronizer.tryAcquireNanos()
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 如果線程中斷了，拋出異常
if (Thread.interrupted())
throw new InterruptedException();
// 先嘗試獲取一次鎖
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout);
}
// AbstractQueuedSynchronizer.doAcquireNanos()
private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 如果時間已經(jīng)到期了，直接返回false
if (nanosTimeout <= 0L)
return false;
// 到期時間
final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
nanosTimeout = deadline - System.nanoTime();
// 如果到期了，就直接返回false
if (nanosTimeout <= 0L)
return false;
// spinForTimeoutThreshold = 1000L;
// 只有到期時間大于1000納秒，才阻塞
// 小于等于1000納秒，直接自旋解決就得了
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
// 阻塞一段時間
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
tryLock(long time, TimeUnit unit)方法在阻塞的時候加上阻塞時間，并且會隨時檢查是否到期，只要到期了沒獲取到鎖就返回false。
unlock()方法
釋放鎖。
// java.util.concurrent.locks.ReentrantLock.unlock()
public void unlock() {
sync.release(1);
}
// java.util.concurrent.locks.AbstractQueuedSynchronizer.release
public final boolean release(int arg) {
// 調(diào)用AQS實現(xiàn)類的tryRelease()方法釋放鎖
if (tryRelease(arg)) {
Node h = head;
// 如果頭節(jié)點不為空，且等待狀態(tài)不是0，就喚醒下一個節(jié)點
// 還記得waitStatus嗎？
// 在每個節(jié)點阻塞之前會把其上一個節(jié)點的等待狀態(tài)設為SIGNAL（-1）
// 所以，SIGNAL的準確理解應該是喚醒下一個等待的線程
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
// java.util.concurrent.locks.ReentrantLock.Sync.tryRelease
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
// 如果當前線程不是占有著鎖的線程，拋出異常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 如果狀態(tài)變量的值為0了，說明完全釋放了鎖
// 這也就是為什么重入鎖調(diào)用了多少次lock()就要調(diào)用多少次unlock()的原因
// 如果不這樣做，會導致鎖不會完全釋放，別的線程永遠無法獲取到鎖
if (c == 0) {
free = true;
// 清空占有線程
setExclusiveOwnerThread(null);
}
// 設置狀態(tài)變量的值
setState(c);
return free;
}
private void unparkSuccessor(Node node) {
// 注意，這里的node是頭節(jié)點
// 如果頭節(jié)點的等待狀態(tài)小于0，就把它設置為0
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 頭節(jié)點的下一個節(jié)點
Node s = node.next;
// 如果下一個節(jié)點為空，或者其等待狀態(tài)大于0（實際為已取消）
if (s == null || s.waitStatus > 0) {
s = null;
// 從尾節(jié)點向前遍歷取到隊列最前面的那個狀態(tài)不是已取消狀態(tài)的節(jié)點
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 如果下一個節(jié)點不為空，則喚醒它
if (s != null)
LockSupport.unpark(s.thread);
}
釋放鎖的過程大致為：
（1）將state的值減1；
（2）如果state減到了0，說明已經(jīng)完全釋放鎖了，喚醒下一個等待著的節(jié)點；
彩蛋
為什么ReentrantLock默認采用的是非公平模式？
答：因為非公平模式效率比較高。
為什么非公平模式效率比較高？
答：因為非公平模式會在一開始就嘗試兩次獲取鎖，如果當時正好state的值為0，它就會成功獲取到鎖，少了排隊導致的阻塞/喚醒過程，并且減少了線程頻繁的切換帶來的性能損耗。
非公平模式有什么弊端？
答：非公平模式有可能會導致一開始排隊的線程一直獲取不到鎖，導致線程餓死。
以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持億速云。
免責聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點不代表本網(wǎng)站立場，如果涉及侵權(quán)請聯(lián)系站長郵箱：is@yisu.com進行舉報，并提供相關證據(jù)，一經(jīng)查實，將立刻刪除涉嫌侵權(quán)內(nèi)容。
