抽象队列同步器——AQS
介绍
AQS（AbstractQueuedSynchronizer），是用来构建锁或者其他同步组建的基础框架，他使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。
子类通过继承AQS这个同步器并实现它的抽象方法来管理同步状态，它既可以支持独占式地获取同步状态，也可以支持共享式地获取同步状态，也是ReentrantLock，CountDownLatch等同步工具实现的基础。
CLH lock queue
AQS其实是一个FIFO队列，队列中的每个节点（线程）需要等前面的节点（线程）释放锁。
结构
如图所示，AbstractQueuedSynchronizer实现了序列化接口，继承了AbstractOwnableSynchronizer，它是一个可能被线程独占的同步器。
AbstractOwnableSynchronizer
该抽象类所有源码如下，内容不多，可以看到主要做了一件事，那就是将该同步器标记（通过属性exclusiveOwnerThread）为一个线程独占的同步器，并提供设置和获取当前线程拥有者的set和get方法。
public abstract class AbstractOwnableSynchronizer
implements java.io.Serializable {
private static final long serialVersionUID = 3737899427754241961L;
protected AbstractOwnableSynchronizer() { }
// 记录该同步器的拥有者
private transient Thread exclusiveOwnerThread;
// 设置拥有同步器的线程
protected final void setExclusiveOwnerThread(Thread thread) {
exclusiveOwnerThread = thread;
}
// 获取当前拥有者
protected final Thread getExclusiveOwnerThread() {
return exclusiveOwnerThread;
}
}
AbstractQueuedSynchronizer
Node（内部类）
我们先来看一下AQS
static final class Node {
// 标记Node为共享式
static final Node SHARED = new Node();
// 标记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;
// 下一个等待者（独占模式为null）
Node nextWaiter;
// 判断当前节点是否为共享模式
final boolean isShared() {
return nextWaiter == SHARED;
}
// 获取线程前一节点
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
// 无参构造
Node() {}
// 有参构造方法1,
Node(Thread thread, Node mode) {
this.nextWaiter = mode;
this.thread = thread;
}
// 有参构造方法2
Node(Thread thread, int waitStatus) {
this.waitStatus = waitStatus;
this.thread = thread;
}
}
Fields
接下来看一下AQS中的属性：
// 记录对列的头结点
private transient volatile Node head;
// 队列的尾节点
private transient volatile Node tail;
// 记录同步状态
private volatile int state;
private static final Unsafe unsafe = Unsafe.getUnsafe();// 获取Unsafe对象
private static final long stateOffset;// 以下为记录属性偏移量
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;
我们重点看一下以下这四个：
- head：用于保存队列的头结点
- tail：保存队列的尾节点
- state：记录节点的同步状态
静态代码块
AQS中的静态代码块主要用于初始化AQS中的state、head、tail和内部类Node中waitStatus、next的偏移量，便于后面使用Unsafe中的CAS方法进行操作：
static {
try {
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
headOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
tailOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
waitStatusOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("waitStatus"));// 内部类waitStatus
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("next"));// 内部类next
} catch (Exception ex) { throw new Error(ex); }
}
Methods
acquire(int) ：获取锁（独占）
acquire()方法用于获取锁，且获取锁的方式为独占。接下来看方法流程：
- 调用tryAcquire() 方法尝试获取资源，从下面的tryAcquire() 的介绍我们可以看到该方法并未实现，而是由子类去根据需求具体实现，返回true则代表成功获得了资源。
- 若未获取到资源，则由addWaiter() 方法将一个标记为独占（nextWaiter=Node.EXCLUSIVE也就是空）的Node添加到等待队列的尾部
- 使用acquireQueued()不断尝试获取资源，期间可能会进入等待(park)状态，如果等待过程中被中断过，则返回true
- 如果线程在获取资源的过程中被中断过，则在获取到资源后（不是直接中断）才进行自我中断（selfInterrupt方法）。
public final void acquire(int arg) {
// 获取到资源直接返回
if (!tryAcquire(arg) &&
//addWaiter(Node.EXCLUSIVE) 等待者为空（独占式）
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// Node.EXCLUSIVE
static final Node EXCLUSIVE = null;
tryAcquire(int)：尝试获取资源
该方式使用了模版方法，具体的实现方式由使用它的类来决定。如ReentrantLock中的实现方式为非公平锁：
// Aqs中的tryAcquire()
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
// ReentrantLock中的实现
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
addWaiter(Node)：添加等待节点
addWaiter()方法用于将当前线程插入等待队列的队尾，并返回当前线程所在的节点node。在acquire() 方法中，可以看到调用该方法入参为Node.EXCLUSIVE，以为独占队列，
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;// 尾节点
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) { // 将node设置为尾节点
pred.next = node;
return node;
}
}
enq(node);// 将node插入到队列中
return node;// 返回当前线程所在的节点
}
enq(Node) ：将节点插入队列
AQS中的enq() 方法用于将一个Node节点插入，这里可以看到入参Node被加上了final关键字，防止在方法中被修改，我们这里把入参node视作当前节点。在enq()方法中，首先进入循环，然后判断队列的尾节点是否为null（尾节点为null则证明未初始化），如果为null，则优先初始化，在初始化方法compareAndSetHead()中，使用了Unsafe中的compareAndSwapObject()将头结点比较并交换为新建节点new Node()。设置完头之后，将头结点也赋值给尾节点。然后进入下一次循环，在该循环中将入参node的前置节点设置为尾节点（在尾节点后添加节点），之后使用compareAndSetTail() 方法比较并交换尾节点为当前节点，成功后将原tail的下一节点替换为当前节点node，最后返回被替换掉的尾节点t。
private Node enq(final Node node) {// Node为final不可被修改
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;
}
}
}
}
// 比较并交换头节点 null：预期值
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}
// 比较并交换尾节点
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
acquireQueued(Node，int)：等待获取资源
acquireQueued() 用于等待获取资源，我们来一起看一下该方法的步骤：
- 首先进入自旋状态，判断前一节点是否为头结点，如果是头结点则尝试获取资源
- 若成功获取到资源则将当前节点设置为头结点，并将原头节点置为可被GC的状态，之后返回线程中断状态
- 若不满足上述条件，则判断前置节点满足线程等待状态后进入等待状态
- 若后续被唤醒，则继续自旋
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);// 将node设置为头结点
p.next = null;// 这里将p.next也设置为null方便GC回收
failed = false;// 成功获取到资源
return interrupted;// return false
}
/*
* 1，检查节点状态(调用shouldParkAfterFailedAcquire()方法)
* 2，之后将该线程设置为等待唤醒状态(调用parkAndCheckInterrupt()方法)
*/
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed) // 获取资源失败
cancelAcquire(node);// 取消节点的等待状态
}
}
// 获取前一个节点，若前一个节点为null，则报空指针异常
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
// 设置头结点为node
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}
shouldParkAfterFailedAcquire(Node，Node)：
shouldParkAfterFailedAcquire()方法用于检查前置节点的状态，同时根据前置节点状态，接下来我们来看一下该方法的步骤：
- 获取当前节点前置节点的等待状态并判断；
- 如果等待状态为Node.SIGNAL即-1时，代表当前节点可以进入等待状态，返回true；
- 若等待状态大于0，即Node.CANCELLED，代表所在线程为取消状态。这时，进入do/while循环将前置节点的前一个节点设置为当前节点node的前置节点（即去除前置节点pred让GC回收），直至前一节点的状态满足pred.waitStatus <= 0;
- 若不满足等待状态大于0，且不等于Node.SIGNAL，则使用CAS将前置节点的等待状态设置为Node.SIGNAL。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;// 获取前置节点的 waitStatus
if (ws == Node.SIGNAL)
// 前置节点状态为Node.SIGNAL，返回true,代表后续节点可以休息（park）
return true;
if (ws > 0) {
// ws>0代表前置线程已经取消等待
do {
/*
* 将前置节点的前一个节点设置为当前节点node的前置节点
* 相当于从队列中除去前置节点pred, 并直到找到下一个状态
* 正常的节点
*/
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;//将往前数第一个状态正常的节点的下一节点设置为node
} else {
// 通过CAS将前置节点的waitStstus设置为Node.SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
parkAndCheckInterrupt()：线程进入等待状态
parkAndCheckInterrupt()方法主要用于使当前线程处于park()状态并返回线程的中断状态。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);// 是当前线程进入等待状态
return Thread.interrupted();// 返回线程是否中断过标识
}
总结
我们来梳理一下整个获取锁的流程：
- 尝试获取资源（tryAcquire），如果未获取到则在对尾添加等待节点（addWaiter）
- 等待节点不断尝试获取锁，期间可能会进入等待状态（LockSupport.park()），获取成功则将当前线程节点设置为头结点（setHead）
- 若线程在获取资源期间有过中断操作，则在获取到资源后进行自我中断
总结流程图如下：
release(int)：释放锁
AQS中的release()方法主要用于获取资源后的释放操作，步骤如下：
- 使用tryRelease()方法释放资源，这里可以看到AQS中未做具体实现，因此需要子类实现该方法时根据情况返回是否释放成功的标志
- 判断头结点
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(int)：尝试释放锁
tryRelease()和tryAcquire()类似，也是AQS为我们提供了一个方法，后续的具体实现方式由子类完成。
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
unparkSuccessor(Node)：唤醒下一个等待者
unparkSuccessor(Node)方法主要用于唤醒Node后第一个处于等待状态的线程。我们回看一下acquireQueued()，可以看出，在此处唤醒后，被唤醒的节点将开始下一次自旋获取资源。自此，若即节点被唤醒，且从acquireQueued()得到了资源，将会返回acquire()方法，结束整个获取资源的过程。
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;// 获取等待状态
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);//CAS操作更新waitStatus=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)
/*
* 唤醒该等待节点，继续自旋
* 若s在被唤醒之前，抛出了异常，就永远无法被unpark了
* 而在这个过程中只有tryRelease()能引发异常
*/
LockSupport.unpark(s.thread);
}
至此，AQS中以独占方式获取资源和释放资源的方法就告一段落了，接下来我们来一起看一下以共享模式下获取资源的过程。
acquireShared(int)：获取锁（共享）
该方法是共享模式下获取资源的入口，我们来看一下方法的步骤：
- 尝试获取资源，成功则直接返回
- 获取失败通过doAcquireShared()进入等待队列，直至获取到资源
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0) // 获取资源失败
doAcquireShared(arg);
}
tryAcquireShared(int)：获取资源
这里和tryAcquire()一样，需要子类去做具体实现，但是返回值有所不同，具体定义如下：
- 返回值为负值代表获取失败
- 返回值为0代表获取成功，但没有资源供后续节点获取
- 返回值为正值则代表获取成功，且后续节点也能获取成功
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
doAcquireShared(int)：排队获取资源
此方法用于将当前线程加入等待队列尾部，并等待被唤醒，直至获取到资源。
private void doAcquireShared(int arg) {
// 添加等待者(共享模式Node.SHARED)
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {// 自旋
final Node p = node.predecessor();// 获取前置节点
if (p == head) {
int r = tryAcquireShared(arg); // 如果是第二个节点尝试获取
if (r >= 0) {// 获取成功
setHeadAndPropagate(node, r);// 设置头并修改状态
p.next = null; // help GC
if (interrupted)
selfInterrupt();// 自我中断
failed = false;
return;
}
}
// 检查节点状态并决定是否休息(park)
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);// 取消节点的等待状态
}
}
setHeadAndPropagate(Node, int)：
设置队列头的同时唤醒后继结点。
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // 记录旧的头结点
setHead(node);// 将node设置为头结点
/*
* propagate > 0代表有资源剩余
*/
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;// 获取下一节点
if (s == null || s.isShared())// 下一节点为空且nextWaiter为共享模式
doReleaseShared();
}
}
doReleaseShared()：
此方法用于唤醒后续节点或修改头结点状态为Node.PROPAGATE。
private void doReleaseShared() {
for (;;) {
Node h = head;// 头结点
if (h != null && h != tail) {// 不为空且非尾节
int ws = h.waitStatus;// 获取状态
if (ws == Node.SIGNAL) {
// 修改状态直至修改成功
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue;
unparkSuccessor(h);// 唤醒下一个等待者
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))// 修改状态
continue; // loop on failed CAS
}
if (h == head)// 返回
break;
}
}
releaseShard(int)：共享模式下释放锁
该方法是共享模式下释放资源的入口，由于在上个方法已经介绍过doReleaseShared()，因此这里不做介绍只是把源码粘贴出来：
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {// 释放
doReleaseShared();
return true;
}
return false;
}
// 模版方法
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
总结
至此我们看完了共享模式和独占模式下释放锁和获取锁的整个过程，也发现了它们的一些不同之处：
- 独占式只有获取到资源的线程释放之后，才会通知后续线程去执行获取资源的过程
- 而共享模式获取的过程中，根据剩余资源的多少，决定其他等待获取资源的线程能否一起获取资源
但是也发现了他们的相同之处：
- 在共享和独占整个获取锁的过程中，是忽略中断的
在整个过程中我们可以发现，AQS替我们简化了锁的实现方式（我们只需要实现AQS提供的模板方法），屏蔽了同步状态管理，线程的排队，等待与唤醒等底层操作，很好地隔离了使用者和实现者所关注的区域。
在后续的学习中，会遇到一些底层使用AQS实现的并发工具，如底层依赖AQS的共享锁实现的CountDownLatch，后面我们会详细讨论：
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
470
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
