本文以ReentrantLock
的非公平锁图解 AQS 独占锁加解锁过程。
前置知识了解
static final class Node {
/** 标记为共享节点 */
static final Node SHARED = new Node();
/** 标记为独占节点 */
static final Node EXCLUSIVE = null;
/** 等待状态值,表示被取消 */
static final int CANCELLED = 1;
/** 等待状态值,表示节点在释放或者取消的时候,需要唤醒下一个节点 */
static final int SIGNAL = -1;
/** 等待状态值,表示线程有条件等待 */
static final int CONDITION = -2;
/** 等待状态值,表示共享锁唤醒了一个节点需要向后传播 */
static final int PROPAGATE = -3;
/** 等待状态 */
volatile int waitStatus;
/** 前驱节点 */
volatile Node prev;
/** 后置节点 */
volatile Node next;
/** 节点关联的线程 */
volatile Thread thread;
}
独占锁加锁
非公平锁加锁的时候代码:
final void lock() {
// 先抢占一次,看看有没有人占有锁,没有自己就拿下,将当前线程设为自己
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
// 抢占失败,那么就去获取独占锁
acquire(1);
}
重点看acquire(1)
:
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
tryAcquire
方法是用来给子类重写的,如果获取成功返回true,则万事大吉,否则进入队列。
先看tryAcquire
方法。
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 获取 AQS 状态
int c = getState();
// 如果等于0则表示无人持有锁,可以去获取锁
if (c == 0) {
// 如果获取锁成功,则将 AQS 线程设置为当前线程,返回 true
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 否则看 AQS 线程是否为当前线程,如果是的话说明当前线程在重入,返回 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;
}
接下来看看进入等待队列的方法,入参是Node.``EXCLUSIVE
,是一个排它锁。
private Node addWaiter(Node mode) {
// 根据当前线程创建出一个节点
Node node = new Node(Thread.currentThread(), mode);
// 获取队列的尾节点
Node pred = tail;
// 如果尾节点存在,那么将尾节点作为当前节点的前置节点
if (pred != null) {
node.prev = pred;
// 通过 cas 将当前节点作为队列的尾节点,这就是成功入队了
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 如果不存在尾节点,则进入 enq(node)
enq(node);
return node;
}
/**
* 将节点插入队列,如果有必要的话会初始化队列
*/
private Node enq(final Node node) {
// 自旋操作
for (;;) {
// 获取尾节点
Node t = tail;
// 如果尾节点为 null,则说明需要初始化队列,初始化完成之后进行下一次自旋,下一次就不会进入这里了
if (t == null) {
// 生成一个 Node 对象,作为头节点,然后将尾节点也指向头节点,此时 tail == head = new Node()
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 如果尾节点不是 null,说明此时队列已经存在,此时再将新的节点插入到队列尾部
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
入队之后的线程该做什么呢,接下来就要看acquireQueued
方法做了什么了,
final boolean acquireQueued(final Node node, int arg) {
// 标记是否失败
boolean failed = true;
try {
// 标记是否中断
boolean interrupted = false;
for (;;) {
// 拿到当前节点的前置节点
final Node p = node.predecessor();
/*
* 如果前置节点是头节点,说明自己排在第一个,可以再次去获取一次锁,
* 如果这一次获取锁成功了,那么将当前节点作为新的头节点,旧的头节点的后置节点置为 null
*/
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
// 此时获取成功了,那么将失败标记置为 false
failed = false;
return interrupted;
}
/*
* 如果前置节点不是头节点,或者前置节点是头节点但是获取锁失败了,此时就要进入这里面了
* 判断在获取锁失败之后,是不是需要 park,如果需要则去 park
*/
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
// 如果失败,则取消获取
if (failed)
cancelAcquire(node);
}
}
看看shouldParkAfterFailedAcquire
方法。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node)
// 前置节点的等待状态
int ws = pred.waitStatus;
// 如果前置节点的等待状态是 SIGNAL,即-1,则表示当前节点如果睡着(park)了,前面的人忙完了会叫醒自己,可以放心的睡了
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
/*
* 如果等待状态大于0,说明前置节点的状态是 CANCELLED(1),被取消了,是不可信任的,自己睡着了的话没人叫醒自己
* 所以只能去找前置节点的前置节点,直到有一个节点的等待状态不是 CANCELLED 的,然后将自己的前置节点置为找到的能信任的节点
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* 进入这里的条件是等待状态为0或者-3(PROPAGATE)
* 此时需要将前置节点的等待状态设为 SIGNAL,并且再次自旋一次,这样才能保证有人能唤醒自己
* 下一次进入这个方法的额时候,就会从 ws == Node.SIGNAL 返回了
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
// 如果返回了false,说明 acquireQueued 方法会继续执行自旋操作,会再次进入 shouldParkAfterFailedAcquire 方法
return false;
}
parkAndCheckInterrupt
的方法就很简单了
private final boolean parkAndCheckInterrupt() {
// park,线程被阻塞在这里了
LockSupport.park(this);
// 在唤醒后返回中断状态
return Thread.interrupted();
}
注意到,在acquireQueued
中的finally
代码块里,有一个cancelAcquire
取消获取锁的方法,什么情况下会进入这里面呢。
在try
里面是一个死循环,只有一个地方会return
,但是return
之前,failed
置为false
了,此时是不会进入cancelAcquire
里面的。所以进入cancelAcquire
方法的原因只有–发生了异常或者当前线程被中断了,这两种情况都是不正常的,所以要取消获取锁。接下来看看cancelAcquire
方法。
private void cancelAcquire(Node node) {
// 如果节点不存在,则不需要处理了
if (node == null)
return;
// 将节点所持有的线程引用置为 null
node.thread = null;
/*
* 如果前置节点已经被取消了,则跳过当前前置节点,将当前节点的前置节点设置为自己的前置节点
* 即,如果本来是 A <-- B <-- Current,如果 B 被取消了,那么现在就是 A <-- Current
*/
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// 前置节点的后置节点,其实就是当前节点,这里是为了用 ACS 移除,所以这么做
Node predNext = pred.next;
// 将当前节点的等待状态设置为 1 CANCELLED
node.waitStatus = Node.CANCELLED;
// 如果当前节点是尾节点,那么将前置节点设置为队列的尾节点,然后将当前节点移除
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
// 如果自己的前置节点答应唤醒后置节点,那么就将自己的后置节点交给前置节点唤醒,否则自己唤醒后置节点,要有责任心
int ws;
// 如果当前节点的前置节点不是头节点
if (pred != head &&
// 并且前置节点的等待状态不是信号唤醒,或者前置节点的等待状态是小于0且成功将其等待状态设置为了 SIGNAL
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
// 并且前置节点的线程不是 null
pred.thread != null) {
//如果后置节点不为 null并且没有被取消,那么将前置节点的后置节点设置为自己的后置节点,自己全身而退
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
// 直接唤醒后置节点
unparkSuccessor(node);
}
// 让自己无牵无挂
node.next = node; // help GC
}
}
独占锁解锁
独占锁解锁过程看 AQS 的release
方法。
public final boolean release(int arg) {
// 尝试释放锁
if (tryRelease(arg)) {
Node h = head;
// 如果头节点不是 null(说明存在队列),并且头节点的状态不是等于0,那么唤醒后置节点
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
// 释放锁失败
return false;
}
看看tryRelease
方法,该方法公平锁和非公平锁是一样的。
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
// 如果 AQS 线程不是当前线程,那么抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
// 释放成功结果
boolean free = false;
/*
* 如果等于0,那么就是释放成功,设置 AQS 持有线程为 null
* 如果不等于0,那就是大于0,此时说明锁被重入了,需要多次释放才行
*/
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
在取消获取锁的时候有一个unparkSuccessor
方法没有分析,在这里进行补充。
private void unparkSuccessor(Node node) {
// 当前节点的等待状态如果小于0,则设置为0,当前节点是要取消的,那么等待状态是1,则不需要进行归0操作
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 当前节点的后续节点
Node s = node.next;
/*
* 如果后置节点为 null或者已经被取消了,那么就从队列的尾节点开始找
* 找到 waitStatus <= 0 的节点来唤醒
*/
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);
}