今天我們來研究學習一下ReentrantLock類的相關原理，ReentrantLock的内部使用AbstractQueuedSynchronizer實作線程鎖。除了ReentrantLock在java.util.concurrent包中還有很多類都依賴于這個類所提供隊列式同步器。
為了友善學習我們以ReentrantLock為例，來學習ReentrantLock和AbstractQueuedSynchronizer。
本節我們先學習ReentrantLock是如何加鎖的。ReentrantLock.lock()内部調用sync.lock()
ReentrantLock的内部有兩種實作，FairSync（公平鎖）和NonfairSync（非公平鎖）都繼承了Sync類，
而Sync類繼承了AbstractQueuedSynchronizer。
AbstractQueuedSynchronizer
AbstractQueuedSynchronizer裡有四個可以重寫的方法，可以用它們實作不同的功能。例如ReentrantLock、CountDownLatch、Semaphore等。
//獨占模式下擷取許可
@Override
protected boolean tryAcquire(int arg) {
return super.tryAcquire(arg);
}
//獨占模式下釋放許可
@Override
protected boolean tryRelease(int arg) {
return super.tryRelease(arg);
}
//共享模式下擷取許可
@Override
protected int tryAcquireShared(int arg) {
return super.tryAcquireShared(arg);
}
//共享模式下釋放許可
@Override
protected boolean tryReleaseShared(int arg) {
return super.tryReleaseShared(arg);
} lock操作
下面将以NonfairSync為例，講解ReentrantLock是如何加鎖。
AbstractQueuedSynchronizer中有一個屬性state，為0時表示沒有線程持有鎖，大于0時表示有鎖。ReentrantLock是可重入表，是以state用于重入計數。
public class ReentrantLock {
private Sync sync;
//加鎖
public void lock() {
sync.lock();
}
static final class NonfairSync extends Sync {
final void lock() {
//CAS方式更新state變量的值，從0更新到1成功表示擷取到鎖
if (compareAndSetState(0, 1))
//記錄獲得鎖的線程
setExclusiveOwnerThread(Thread.currentThread());
else
//其他線程已經擷取鎖走acquire
acquire(1);
}
}
abstract static class Sync extends AbstractQueuedSynchronizer {
......
}
} acquire
acquire函數的作用是擷取同一時間段内隻能被一個線程擷取的許可。
先調用tryAcquire嘗試擷取一次鎖，如果失敗則調用acquireQueued等待鎖。
public final void acquire(int arg) {
//tryAcquire嘗試擷取鎖
//但是多線程搶鎖可能目前線程搶不到，走acquireQueued
//addWaiter為目前線程建立一個WaitNode節點加入隊列（連結清單）
if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
selfInterrupt();
}
}
//嘗試擷取一次鎖
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//state為0表示沒有人持有鎖，可以嘗試擷取鎖
if (c == 0) {
//CAS方式更新state變量的值，從0更新到1成功表示擷取到鎖
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;
} addWaiter
AbstractQueuedSynchronizer中實作了連結清單，用于儲存所有的等待鎖的線程調用addWaiter将目前線程封裝成連結清單中的一個節點加傳入連結表中。
//連結清單頭節點
private transient volatile Node head;
//連結清單尾節點
private transient volatile Node tail;
//addWaiter為目前線程建立一個WaitNode節點加入隊列（連結清單）
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
//嘗試向連結清單加入節點
//第一次調用addWaiter時tail為null，直接走enq
Node pred = tail;
if (pred != null) {
node.prev = pred;
//CAS方式插入node
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
private Node enq(final Node node) {
//不停嘗試插入node
for (;;) {
Node t = tail;
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
} acquireQueued
addWaiter成功後，調用acquireQueued等待其他線程釋放鎖後重新擷取鎖。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//不停嘗試擷取鎖
for (;;) {
//擷取前驅節點
final Node p = node.predecessor();
//前驅節點是頭節點時tryAcquire
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (//檢查node狀态
shouldParkAfterFailedAcquire(p, node)
//阻塞線程
//如果parkAndCheckInterrupt==true時線程已經中斷
&& parkAndCheckInterrupt()) {
interrupted = true;
}
}
} finally {
if (failed)
cancelAcquire(node);
}
} park
如果其他線程持有鎖，那麼讓目前線程阻塞。等到其他線程釋放鎖時喚醒線程
static final int CANCELLED = 1;
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//檢查前驅節點waitStatus（初始化時值為0）
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
//如果前繼的節點狀态為SIGNAL，表示目前節點需要阻塞
return true;
if (ws > 0) {
//過濾掉所有cancelled的節點
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
private final boolean parkAndCheckInterrupt() {
//阻塞線程, 等待其他線程釋放鎖
LockSupport.park(this);
//傳回false，表示線程沒有中斷
return Thread.interrupted();
} 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)
//喚醒下一個Node中的線程
unparkSuccessor(h);
return true;
}
return false;
}
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;
}
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
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)
//喚醒線程
LockSupport.unpark(s.thread);
} ![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)