抽象队列同步器——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;
}
}
}