只談?wù)劻段猓蝗采w
簡(jiǎn)單介紹重入鎖
ReentrantLock為并發(fā)包多數(shù)的類提供底層應(yīng)用鹿鳖。重要性不言而喻，重入鎖實(shí)現(xiàn)的基石就是AbstractQueuedSynchronizer壮莹。所以把AbstractQueuedSynchronizer研究透翅帜，就可以摸清重入鎖是如何實(shí)現(xiàn)的。
ReentrantLock的Sync內(nèi)部類繼承了AbstractQueuedSynchronizer命满，ReentrantLock的非公平鎖與公平鎖都繼承了Sync
- 公平鎖
先判斷如果當(dāng)前線程之前的節(jié)點(diǎn)沒有排隊(duì)的線程（hasQueuedPredecessors涝滴， 就是要乖乖的按順序排隊(duì)），則當(dāng)前線程可以獲取鎖胶台，否則插入隊(duì)尾等待喚醒歼疮。 - 非公平鎖
上來(lái)就先搶占鎖，如果搶占不到再去嘗試獲取鎖（nonfairTryAcquire诈唬，各種搶占誰(shuí)搶到算誰(shuí)的）韩脏，如果獲取不到，則插入隊(duì)尾等待喚醒铸磅。
拿公平鎖舉例
通過(guò)一段代碼赡矢，闡述下，ReentrantLock的公平鎖是如果做到線程同步的阅仔。
public void lockT() {
ReentrantLock lock = new ReentrantLock(true); // 公平鎖
for (int i = 0; i < 5; i++) { // 模擬5個(gè)線程執(zhí)行
singleThreadPool.execute(() -> {
lock.lock(); // 上鎖
try {
System.out.println(Thread.currentThread().getName());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock(); // 解鎖
});
}
singleThreadPool.shutdown();
}
- 等待隊(duì)列節(jié)點(diǎn)類
static final class Node {
// 共享模式節(jié)點(diǎn)
static final Node SHARED = new Node();
// 獨(dú)占模式節(jié)點(diǎn)
static final Node EXCLUSIVE = null;
// 表示線程已被取消
static final int CANCELLED = 1;
// 表示后續(xù)線程需要喚醒（線程可被喚醒的標(biāo)識(shí)）
static final int SIGNAL = -1;
// 表示線程正在等待條件
static final int CONDITION = -2;
// 傳播等待狀態(tài)吹散，表示無(wú)條件傳播（執(zhí)行）
static final int PROPAGATE = -3;
// 對(duì)于正常同步節(jié)點(diǎn)，此字段初始化為0霎槐，對(duì)于條件節(jié)點(diǎn)初始化值應(yīng)該是 CONDITION -2送浊。waitStatus 對(duì)應(yīng)以上狀態(tài)值（CANCELLED、SIGNAL 丘跌、CONDITION、PROPAGATE）唁桩。
volatile int waitStatus;
// 當(dāng)前節(jié)點(diǎn)的前一個(gè)節(jié)點(diǎn)
volatile Node prev;
// 當(dāng)前節(jié)點(diǎn)的后一個(gè)節(jié)點(diǎn)
volatile Node next;
// 正在排隊(duì)的線程節(jié)點(diǎn)闭树。在構(gòu)造時(shí)初始化，并在使用后清除
volatile Thread thread;
// 鏈接下一個(gè)正在等待條件的節(jié)點(diǎn)荒澡，或者指定值為 SHARED 的節(jié)點(diǎn)报辱。因?yàn)闂l件隊(duì)列只有當(dāng)持有獨(dú)占模式下時(shí)才能被訪問(wèn)，我們只需要一個(gè)簡(jiǎn)單的鏈隊(duì)列去保持正在等待條件的節(jié)點(diǎn)单山。他們?cè)谶@個(gè)隊(duì)列中轉(zhuǎn)換成重新獲劝帧（re-acquire）節(jié)點(diǎn)。并且條件只能為獨(dú)占米奸，所以我們使用這個(gè)屬性來(lái)保存特殊的值昼接，表示為一個(gè)共享模式
Node nextWaiter;
// 如果節(jié)點(diǎn)在共享模式下等待，則返回 true
final boolean isShared() {
return nextWaiter == SHARED;
}
// 返回前一個(gè)節(jié)點(diǎn)悴晰，或者如果為空拋出空指針異常慢睡。當(dāng)前一個(gè)不為空時(shí)可以使用逐工。
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
Node() { // Used to establish initial head or SHARED marker
}
Node(Thread thread, Node mode) { // Used by addWaiter 使用的等待模式
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) { // Used by Condition 使用的等待狀態(tài)
this.waitStatus = waitStatus;
this.thread = thread;
}
}
- 上鎖
public void lock() {
sync.lock();
}
final void lock() {
acquire(1);
}
public final void acquire(int arg) {
// 嘗試獲取鎖失敗，并且成功加入等待隊(duì)列漂辐。線程自己中斷泪喊。
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
- 首先嘗試獲取鎖
tryAcquire
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread(); // 獲取當(dāng)前線程
int c = getState(); // 同步狀態(tài)， 狀態(tài)為0時(shí)表示鎖空閑髓涯，當(dāng)前線程可以獲取鎖
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) { // 表示當(dāng)前線程之前的線程是否有排隊(duì)的袒啼，如果有跳出 if瘤泪，沒有就走原子更新狀態(tài)從0變1.表示該鎖已被占用
setExclusiveOwnerThread(current); // 設(shè)置獨(dú)占線程所有者為當(dāng)前線程
return true;
}
}
else if (current == getExclusiveOwnerThread()) { // cpu 時(shí)間片对途，鎖重入
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// 每次公平鎖都要進(jìn)行這個(gè)判斷实檀。如果在當(dāng)前線程之前有一個(gè)排隊(duì)的線程返回true签则，如果當(dāng)前線程在隊(duì)列的頭或者隊(duì)列為空返回false
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread()); // 首尾不相等 并且 s 為隊(duì)頭的下一個(gè)節(jié)點(diǎn)為空或者 s 的線程不等于當(dāng)前線程
}
- 獲取鎖失敗后，把當(dāng)前線程組裝成新的節(jié)點(diǎn)加入到等待隊(duì)列中。
private Node addWaiter(Node mode) {
// 要添加等待隊(duì)列的線程節(jié)點(diǎn)
Node node = new Node(Thread.currentThread(), mode);
// 嘗試把新的節(jié)點(diǎn)插入在隊(duì)列的尾部
// pred 指向隊(duì)尾
Node pred = tail;
// 如果隊(duì)尾有值，則進(jìn)行 cas 隊(duì)尾替換，并移動(dòng)上一個(gè)隊(duì)尾的指針
if (pred != null) {
// 不為空時(shí)盖奈，新節(jié)點(diǎn)的前一個(gè)指向隊(duì)尾，隊(duì)尾的后一個(gè)節(jié)點(diǎn)指向新節(jié)點(diǎn)
node.prev = pred;
// 隊(duì)尾原子替換
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 如果隊(duì)尾為空或者隊(duì)尾原子替換失敗，則走 enq 方法
enq(node);
// 返回新節(jié)點(diǎn)
return node;
}
private Node enq(final Node node) { // final 類型的節(jié)點(diǎn)
// 自旋
for (;;) {
// t 指向隊(duì)尾的引用
Node t = tail;
// 如果 t 為空必須要初始化一個(gè)空的隊(duì)頭
if (t == null) {
// 成功初始化一個(gè)空的隊(duì)頭
if (compareAndSetHead(new Node()))
// 隊(duì)尾指向空隊(duì)頭的引用
tail = head;
} else { // 如果 t 不為空，將節(jié)點(diǎn)插入隊(duì)尾
// 參數(shù)節(jié)點(diǎn)的前一個(gè)值指向 t
node.prev = t;
// 進(jìn)行尾部的原子替換，把 t 替換成 node
if (compareAndSetTail(t, node)) {
// 成功后，t 的下一個(gè)節(jié)點(diǎn)指向參數(shù) node
t.next = node;
// 返回前一個(gè)節(jié)點(diǎn)
return t;
}
}
}
}
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
// 自旋
for (;;) {
// 獲取前一個(gè)節(jié)點(diǎn)
final Node p = node.predecessor();
// 如果是隊(duì)頭并且重新嘗試獲取鎖成功腰懂。 當(dāng)前節(jié)點(diǎn)是否是重新獲取鎖時(shí)的當(dāng)前線程？？答案：是的
if (p == head && tryAcquire(arg)) {
// 隊(duì)頭指向隊(duì)頭的下一個(gè)節(jié)點(diǎn)艘虎，使老隊(duì)頭出列（設(shè)置新隊(duì)頭，老隊(duì)頭出列），先進(jìn)先出
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 如果 p 不是隊(duì)頭并且獲取鎖失敗后阻塞當(dāng)前線程目溉，自旋阻塞
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
// 獲取鎖失敗之后暫掛（阻塞）該線程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 前節(jié)點(diǎn)的等待狀態(tài)
int ws = pred.waitStatus;
// 前一個(gè)節(jié)點(diǎn)的等待狀態(tài)為-1，表示當(dāng)前線程可以安全的阻塞
if (ws == Node.SIGNAL)
/*
* 前置節(jié)點(diǎn)已經(jīng)是 SIGNAL 狀態(tài)，所以當(dāng)前線程可以被安全阻塞
*/
return true;
if (ws > 0) {
/*
* ws > 0 表示前節(jié)點(diǎn)已經(jīng)被取消，跳過(guò)等待狀態(tài)大于0的前節(jié)點(diǎn)并重試
*/
do {
// 跳過(guò)狀態(tài)大于0的節(jié)點(diǎn)
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* 等待狀態(tài)必須為0或者為 PROPAGATE搁凸。我們需要一個(gè)等待狀態(tài)變?yōu)?signal，這時(shí)還沒有阻塞护糖。調(diào)用者需要重試褥芒，確保它在阻塞前不能獲取鎖
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL); // 把前一個(gè)節(jié)點(diǎn)的狀態(tài)由0或者 PROPAGATE 變?yōu)?SIGNAL
}
return false;
}
private final boolean parkAndCheckInterrupt() {
// 掛起（阻塞）當(dāng)前線程
LockSupport.park(this);
return Thread.interrupted();
}
上鎖總結(jié)
至此關(guān)于重入鎖上鎖部分的源碼分析完畢锰扶。其實(shí)很簡(jiǎn)單，并發(fā)時(shí)只有當(dāng)線程獲取到鎖時(shí)讯蒲，才能進(jìn)行之后的邏輯操作，如果線程沒有獲取到鎖時(shí)酌呆，則會(huì)被加入雙向鏈表中衡载。公平鎖獲取鎖時(shí)每次會(huì)通過(guò)hasQueuedPredecessors方法判斷當(dāng)前線程是否為排隊(duì)的第一個(gè)線程（fifo先進(jìn)先出）。
大體流程圖
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
tryAcquire()
hasQueuedPredecessors()
compareAndSetState()
setExclusiveOwnerThread()
getExclusiveOwnerThread()
addWaiter()
compareAndSetTail()
enq()
acquireQueued()
tryAcquire()
shouldParkAfterFailedAcquire()
parkAndCheckInterrupt()
cancelAcquire()
============
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;
}
tryRelease()
setExclusiveOwnerThread()
setState()
unparkSuccessor()
compareAndSetWaitStatus()
unpark()
