溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇“ReentrantLock源碼分析Java多線程”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“ReentrantLock源碼分析Java多線程”文章吧。
管程（Monitor）是一種用于實現多線程同步的抽象數據類型，它可以用來協調不同線程之間的互斥和同步訪問共享資源。通俗地說，管程就像一個門衛，控制著進入某個共享資源區域的線程數量和時間，以避免多個線程同時訪問導致的數據競爭和混亂。
Mesa管程模型：由美國計算機科學家Dijkstra提出，是最流行的管程模型之一。在Mesa管程模型中，每個管程也有一個條件變量和等待隊列，但與Hoare管程不同的是，當一個線程請求進入管程時，如果條件不滿足，該線程并不會立即被阻塞，而是繼續執行后續操作，直到該線程主動放棄鎖資源或者其他線程喚醒它。
Hoare管程模型：由英國計算機科學家C.A.R. Hoare提出，是最早的管程模型之一。在Hoare管程模型中，每個管程都有一個條件變量和一個等待隊列，當一個線程請求進入管程時，如果條件不滿足，該線程就會被阻塞并加入等待隊列，直到條件滿足后才被喚醒。
Brinch Hansen管程模型：由丹麥計算機科學家Per Brinch Hansen提出，是一種改進的管程模型。在Brinch Hansen管程模型中，每個管程也有一個條件變量和等待隊列，但與其他管程模型不同的是，它允許多個線程同時在管程中等待，并且不需要像Hoare管程那樣每次只喚醒一個等待線程。
在Java中，采用的是基于Mesa管程模型實現的管程機制。具體地，Java中的synchronized關鍵字就是基于Mesa管程模型實現的，包括Java中的AbstractQueuedSynchronizer（AQS）可以被看作是一種基于管程模型實現的同步框架。
互斥訪問
MESA模型采用了互斥訪問的機制，即同一時刻只能有一個線程進入管程執行代碼。
條件變量
MESA模型還引入了條件變量的概念，用于實現線程間的等待和喚醒操作。條件變量提供了一種機制，使得線程可以在等待某個條件成立時掛起，并在條件成立時被喚醒。
等待隊列
MESA模型使用等待隊列來維護處于等待狀態的線程，這些線程都在等待條件變量成立。等待隊列由一個或多個條件變量組成，每個條件變量都有自己的等待隊列。
原子操作
MESA模型要求管程中的所有操作都是原子操作，即一旦進入管程，就不能被中斷，直到操作執行完畢。
在講ReentrantLock之前先說一下AQS，AQS（AbstractQueuedSynchronizer）是Java中的一個同步器，它是許多同步類（如ReentrantLock、Semaphore、CountDownLatch等）的基礎。AQS提供了一種實現同步操作的框架，其中包括獨占模式和共享模式，以及一個等待隊列來管理線程的等待和喚醒。AQS也借鑒了Mesa模型的思想。
AQS內部維護了屬性volatile int state表示資源的可用狀態
state三種訪問方式:
getState()
setState()
compareAndSetState()
Exclusive-獨占，只有一個線程能執行，如ReentrantLock
Share-共享，多個線程可以同時執行，如Semaphore/CountDownLatch
isHeldExclusively()：該線程是否正在獨占資源。只有用到condition才需要去實現它。
tryAcquire(int)：獨占方式。嘗試獲取資源，成功則返回true，失敗則返回false。
tryRelease(int)：獨占方式。嘗試釋放資源，成功則返回true，失敗則返回false。
tryAcquireShared(int)：共享方式。嘗試獲取資源。負數表示失敗；0表示成功，但沒有剩余可用資源；正數表示成功，且有剩余資源。
tryReleaseShared(int)：共享方式。嘗試釋放資源，如果釋放后允許喚醒后續等待結點返回true，否則返回false
同步等待隊列： 主要用于維護獲取鎖失敗時入隊的線程。
條件等待隊列： 調用await()的時候會釋放鎖，然后線程會加入到條件隊列，調用signal()喚醒的時候會把條件隊列中的線程節點移動到同步隊列中，等待再次獲得鎖。
值為0，初始化狀態，表示當前節點在sync隊列中，等待著獲取鎖。
CANCELLED，值為1，表示當前的線程被取消；
SIGNAL，值為-1，表示當前節點的后繼節點包含的線程需要運行，也就是unpark；
CONDITION，值為-2，表示當前節點在等待condition，也就是在condition隊列中；
PROPAGATE，值為-3，表示當前場景下后續的acquireShared能夠得以執行；
在ReentrantLock中有一個內部類Sync會繼承 AQS然后將同步器所有調用都映射到Sync對應的方法。
/**
* Creates an instance of {@code ReentrantLock}.
* This is equivalent to using {@code ReentrantLock(false)}.
*/
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* 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();
}ReentrantLock還提供了一個傳布爾值的實例化方式，這個傳true用來創建一個公平鎖的，默認是創建非公平鎖。非公平鎖的話 sync是用NonfairSync來進行實例化，公平鎖sync是用FairSync來進行實例化。
現在假設有AB兩個線程來競爭鎖
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
//CAS修改state狀態
if (compareAndSetState(0, 1))
//修改成功設置exclusiveOwnerThread
setExclusiveOwnerThread(Thread.currentThread());
else
//嘗試獲取資源
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}假定A線程先CAS修改成功，他會設置exclusiveOwnerThread為A線程
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}我們先看tryAcquire()方法，這里體現出了他的可重入性。
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
//獲取當前資源標識
int c = getState();
if (c == 0) {
//如果資源沒被占有CAS嘗試加鎖
if (compareAndSetState(0, acquires)) {
//修改成功設置exclusiveOwnerThread
setExclusiveOwnerThread(current);
return true;
}
}
//資源被占有要判斷占有資源的線程是不是當前線程，加鎖成功設置的exclusiveOwnerThread值在這里就派上了用處
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線程嘗試加鎖是失敗的，接下來看嘗試加鎖失敗后的方法acquireQueued(addWaiter(Node.EXCLUSIVE), arg),該方法實現分為兩個部分:
addWaiter(Node.EXCLUSIVE)：該方法會將當前線程加入到等待隊列（即 Sync 中的 queue）的尾部，并返回該節點。這個節點的模式是獨占模式（Node.EXCLUSIVE），表示當前線程想要獲取獨占鎖。
acquireQueued(Node node, int arg)：該方法是一個循環方法，用于等待和獲取鎖。
我們先解析addWaiter
private Node addWaiter(Node mode) {
//構建一個當前線程的node節點 這里prev 和 next 都為null
Node node = new Node(Thread.currentThread(), mode);
// 指向雙向鏈表的尾節點的引用
Node pred = tail;
//B線程進來目前還未構建任何隊列這里肯定是空的
if (pred != null) {
//如果已經構建過隊列會把當前線程的node節點的上一個node節點指向tail尾節點
node.prev = pred;
//CAS操作把當前線程的node節點設置為新的tail尾節點
if (compareAndSetTail(pred, node)) {
//把舊的tail尾節點的下一個node節點指向當前線程的node節點
pred.next = node;
return node;
}
}
//尾節點為空執行
enq(node);
return node;
}private Node enq(final Node node) {
//死循環當tail 尾節點不為空才會跳出
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
//用CAS構建出一個head空的node節點
if (compareAndSetHead(new Node()))
//將當前空的node節點交給尾節點（下一次循環就會走else分支）
tail = head;
} else {
//把我們addWaiter中創建的node節點的prev指向了當前線程node節點
node.prev = t;
//將tail尾節點更改為當前線程的node節點
if (compareAndSetTail(t, node)) {
//將t的下一個節點指向當前線程創建的node節點
t.next = node;
return t;
}
}
}
}執行完這里初步的一個等待隊列就構建好了
解析完addWaiter我們再來解析acquireQueued,addWaiter執行完后的結果會返回一個雙向列表的node節點
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
//中斷標志位
boolean interrupted = false;
for (;;) {
//獲取當前線程node節點的上一個節點
final Node p = node.predecessor();
//如果上一個節點就是head節點說明當前線程其實是處在隊列第一位然后就會再次嘗試加鎖
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//這里是重點 這個方法來判斷當前線程是否應該進入等待狀態
if (shouldParkAfterFailedAcquire(p, node) &&
//調用LockSupport.park(this)阻塞了當前線程等待被喚醒
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//獲取上一個節點的等待狀態
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)//表示當前節點的后繼節點包含的線程需要運行
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) {//當前線程被取消
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//設置等待狀態為-1
}
return false;
}運行到parkAndCheckInterrupt()B線程就會被阻塞了，后續的邏輯我們在解鎖操作unlock之后再繼續說
public void unlock() {
sync.release(1);
}public final boolean release(int arg) {
//嘗試釋放鎖
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
//head節點不為空并且等待狀態不是0就去進行unpark操作
unparkSuccessor(h);
return true;
}
return false;
}private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
//head節點等待狀態
int ws = node.waitStatus;
//
if (ws < 0)
//將頭節點的等待狀態修改為0
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
//獲取頭節點的下一個節點(也就是B節點)
Node s = node.next;
if (s == null || s.waitStatus > 0) {//節點為空或者線程處于取消狀態
s = null;
//從尾節點往上找符合條件的節點
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
//對該線程進行unpark喚醒(B節點)
LockSupport.unpark(s.thread);
}
喚醒之后我們的B線程就能繼續往下走了，我們繼續看剛剛的acquireQueued()方法
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
//這里嘗試獲取鎖由于A線程釋放了鎖這里是肯定獲取成功的
if (p == head && tryAcquire(arg)) {
//把head設置為當前節點（也就是往前移一位,并且把上一個節點指向指為null）
setHead(node);
//把剛剛的上一個節點也指向為null (這里他就沒引用了會被GC回收掉)
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
//剛剛在這里阻塞現在被喚醒
parkAndCheckInterrupt())
//設置標志中斷位為true 然后開始下一次循環
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}以上就是關于“ReentrantLock源碼分析Java多線程”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
