AQS 源码解读系列--ReentrantLock 篇
在 JDK1.6 之前，JDK 中实现同步我们只能使用 synchronized 关键字，尽管从 JDK1.5 开始 Java 官方对重量级的 synchronized 进行了升级，引入了偏向锁及自旋锁，使得语言层面的锁更加的轻量和高效，但是始终不能满足用户对锁灵活控制的需求，所以才有了 ReentrantLock 的出现。
1. lock()
1.1 时序图
1.2 源码解读
ReentrantLock.lock()
public void lock() {
sync.lock();
}
NonfairSync.lock()
final void lock() {
// 非公平锁，上来就去尝试获取锁
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
// 获取失败，进入自旋获取锁的逻辑
acquire(1);
}
AbstractQueuedSynchronizer.acquire()
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
// 再次非公平的尝试获取锁失败，将当前线程构建成 Node 节点，加入等待队列
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
NonfairSync.tryAcquire()
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
Sync.nonfairTryAcquire()
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();// state 表示锁被获取的次数
// 这里再次体现了锁的非公平性，此时不是去乖乖的排队等待，而是再次尝试获取锁
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");
// 因为当前线程即为锁的 owner，因此这里不需要 CAS，而是直接更新
setState(nextc);
return true;
}
return false;
}
AbstractQueuedSynchronizer.addWaiter()
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;
// 等待队列是一个双向链表
// 如果尾节点不为空，将当前线程构建成的节点通过 CAS 添加到队列的尾部
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 如果队列为空，或者加入队列的时候失败，进入这里的逻辑
enq(node);
return node;
}
private Node enq(final Node node) {
for (;;) {
Node t = tail;
// 尾节点为空，说明此时是空队列，构造一个空节点作为头节点
// 头节点代表当前获得锁的线程对应的节点
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {// 如果尾不为空，当前线程会自旋入队
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
AbstractQueuedSynchronizer.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;
}
// 如果前驱节点不是头节点，或者上面的获取锁操作失败，会走到这里
// 通过 shouldParkAfterFailedAcquire 方法我们可以知道：
// 当前线程会把前驱线程的 waitStatus 值设置为 -1，代表唤醒
// 当前驱节点获得锁并释放后，会根据这个 waitStatus 去判断是否需要唤醒后继线程
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 如果线程被挂起的过程中被中断过，会返回 true
// 最终会在 acquire() 方法中调用 selfInterrupt() 方法，
// 执行线程的 interrupt() 方法进行中断
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);
}
return false;
}
private final boolean parkAndCheckInterrupt() {
// 将当前线程挂起
LockSupport.park(this);
// 返回当前线程的中断标识
return Thread.interrupted();
}
1.3 总结
当我们使用 ReentrantLock 的时候，如果不指定，默认会使用非公平锁。并发大师 Doug Lea 将非公平锁作为默认的可重入锁的实现，这里比较侧重的是锁的获取效率，我们在实际使用时可以根据具体需求进行选择。
public ReentrantLock() {
sync = new NonfairSync();
}
下面我们通过与公平锁的对比，来分析一下非公平锁的非公平性到底体现在哪里。
- FairSync.lock() VS NonfairSync.lock()
final void lock() {
acquire(1);
}
final void lock() {
// 上来先去试着获取锁，不管锁是否被获取过
// 不成功再说，万一成功了呢
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
- FairSync.tryAcquire() VS Sync.nonfairTryAcquire()
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;
}
}
// 如果锁没有被释放，判断当前线程是否是锁的 owner，如果是，直接重入
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {// 锁被释放
// 不管是否有前驱线程，直接去获取锁
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果锁没有被释放，判断当前线程是否是锁的 owner，如果是，直接重入
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;
}
2. unlock()
2.1 时序图
2.2 源码解读
public void unlock() {
sync.release(1);
}
AbstractQueuedSynchronizer.release()
public final boolean release(int arg) {
if (tryRelease(arg)) {// 先去释放锁
Node h = head;
if (h != null && h.waitStatus != 0)
// 如果代表锁 owner 的头节点存在，并且 waitStatus 不为初始值，
// 唤醒后继节点
unparkSuccessor(h);
return true;
}
return false;
}
Sync.tryRelease()
protected final boolean tryRelease(int releases) {
// 重入的情况，进来几次就要退出几次，锁才能最终被释放
int c = getState() - releases;
// 当前线程不是锁的 owner，抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
AbstractQueuedSynchronizer.unparkSuccessor()
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.
*/
int ws = node.waitStatus;
if (ws < 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.
*/
Node s = node.next;
// 如果头节点的后继节点为空或者已经被取消
if (s == null || s.waitStatus > 0) {
// 从尾节点向前遍历，找到最后一个需要被唤醒的节点，
// 即队列中的第一个没有被取消的节点，然后将其唤醒
// 这里有一个疑问，为什么要从前往后进行遍历？
// addWaiter() 和 enq() 两个方法中，节点入队的时候，
// 先执行的都是 node.prev = pred; 然后再通过 CAS 将当前节点设置成尾节点，
// 设置成功后再将前驱节点的后继节点设置为当前节点。
// 因此如果从前往后遍历，可能会出现断链的情况
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);
}
2.3 总结
关于锁的释放，逻辑比较简单，没什么可说。这里说一下 AQS 中的 waitStatus 的含义，理解其含义对 AQS 体系的源码解读会有所帮助。
源码中对 waitStatus 的解释如下：
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;// 被取消的线程的状态
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;// 标识后继线程需要被唤醒
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;// 标识当前线程等待在 condition 条件上
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;// 用于共享锁，标识传播共享标识
/**
* Status field, taking on only the values:
* SIGNAL: The successor of this node is (or will soon be)
* blocked (via park), so the current node must
* unpark its successor when it releases or
* cancels. To avoid races, acquire methods must
* first indicate they need a signal,
* then retry the atomic acquire, and then,
* on failure, block.
* CANCELLED: This node is cancelled due to timeout or interrupt.
* Nodes never leave this state. In particular,
* a thread with cancelled node never again blocks.
* CONDITION: This node is currently on a condition queue.
* It will not be used as a sync queue node
* until transferred, at which time the status
* will be set to 0. (Use of this value here has
* nothing to do with the other uses of the
* field, but simplifies mechanics.)
* PROPAGATE: A releaseShared should be propagated to other
* nodes. This is set (for head node only) in
* doReleaseShared to ensure propagation
* continues, even if other operations have
* since intervened.
* 0: None of the above
*
* The values are arranged numerically to simplify use.
* Non-negative values mean that a node doesn't need to
* signal. So, most code doesn't need to check for particular
* values, just for sign.
*
* The field is initialized to 0 for normal sync nodes, and
* CONDITION for condition nodes. It is modified using CAS
* (or when possible, unconditional volatile writes).
*/
volatile int waitStatus;