1.概念
队列同步器AbstractQueuedSynchronizer(后面简称AQS)是实现锁和有关同步器的一个基础框架,其内部通过一个被标识为volatile的名为state的变量来控制多个线程之间的同步状态。多个线程之间可以通过AQS来独占式或共享式的抢占资源。
例如,在锁这个问题上,Java中提供的是synchronized关键字,用这个关键字可以很方便的实现多个线程之间的同步。但这个关键字也有很多缺陷,比如:
- 他不支持超时的获取锁,一个线程一旦没有从synchronized上获取锁,就会卡在这里,没有机会逃脱。所以通常由synchronized造成的死锁是无解的。
- 不可响应中断。
- 不能尝试获取锁。如果尝试获取时没获取到,立刻返回,synchronized不具备这一特性。
而ReentrantLock基于AQS将上述几点都做到了。
2.核心结构
从AbstractQueuedSynchronizer的名字可以看出,AQS中一定是基于队列实现的(Queue)。在AQS内部,是通过链表实现的队列。链表的每个元素是其内部类Node的一个实现。然后AQS通过实例变量head指向队列的头,通过实例变量tail指向队列的尾。
源码:
/**
* Head of the wait queue, lazily initialized. Except for
* initialization, it is modified only via method setHead. Note:
* If head exists, its waitStatus is guaranteed not to be
* CANCELLED.
*/
private transient volatile Node head;
/**
* Tail of the wait queue, lazily initialized. Modified only via
* method enq to add new wait node.
*/
private transient volatile Node tail;
/**
* The synchronization state.
*/
private volatile int state;
static final class Node {
/** 标识为共享式 */
static final Node SHARED = new Node();
/** 标识为独占式 */
static final Node EXCLUSIVE = null;
/** 同步队列中等待的线程等待超时或被中断,需要从等待队列中取消等待,进入该状态的节点状态将不再变化 */
static final int CANCELLED = 1;
/** 当前节点的后继节点处于等待状态,且当前节点释放了同步状态,需要通过unpark唤醒后继节点,让其继续运行 */
static final int SIGNAL = -1;
/** 当前节点等待在某一Condition上,当其他线程调用这个Conditino的signal方法后,该节点将从等待队列恢复到同步队列中,使其有机会获取同步状态 */
static final int CONDITION = -2;
/** 表示下一次共享式同步状态获取状态将无条件的传播下去 */
static final int PROPAGATE = -3;
/* 当前节点的等待状态,取值为上述几个常量之一,另外,值为0表示初始状态 */
volatile int waitStatus;
/* 前驱节点 */
volatile Node prev;
/* 后继节点 */
volatile Node next;
/* 等待获取同步状态的线程 */
volatile Thread thread;
/* 等待队列中的后继节点 */
Node nextWaiter;
// ...
}
3.实现原理
AQS提供了几个模板方法供实现类自己实现定制功能。
这几个方法是:
- boolean tryAcquire(int arg):独占式的获取同步状态,通常通过以CAS的方式修改state的值来实现特定功能。
- boolean tryRelease(int arg):独占式的释放同步状态,通常也是修改state的值。
- int tryAcquireShared(int arg):共享式的获取同步状态,返回值>=0表示成功,否则失败。
- boolean tryReleaseShared(int arg):共享式的释放同步状态,同样通过修改state值来实现。
- boolean isHeldExclusively():表示AQS是否被当前线程独占。
这几个方法的默认实现都会抛出UnsupportedOperationException异常。
目前我们不用关心这几个方法,只要明白其内部是通过控制state的值来管理同步状态即可。
3.1 同步状态的获取
通常,实现类会优先尝试修改state的值,来获取同步状态。例如,如果某个线程成功的将state的值从0修改为1,表示成功的获取了同步状态。 这个修改的过程是通过CAS完成的,所以可以保证线程安全。
反之,如果修改state失败,则会将当前线程加入到AQS的队列中,并阻塞线程。
AQS内部提供了三个方法来修改state的状态,其源码如下:
/**
* Returns the current value of synchronization state.
* This operation has memory semantics of a {@code volatile} read.
* @return current state value
*/
protected final int getState() {
return state;
}
/**
* Sets the value of synchronization state.
* This operation has memory semantics of a {@code volatile} write.
* @param newState the new state value
*/
protected final void setState(int newState) {
state = newState;
}
/**
* Atomically sets synchronization state to the given updated
* value if the current state value equals the expected value.
* This operation has memory semantics of a {@code volatile} read
* and write.
*
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful. False return indicates that the actual
* value was not equal to the expected value.
*/
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
3.2 同步队列
AQS内部实际上是一个FIFO的双端队列,当线程获取同步状态失败时,就会构建一个Node并添加到队列尾部(此过程是线程安全的,CAS实现),并阻塞当前线程(通过LockSupport.park()方法); 当释放同步状态时,AQS会先判断head节点是否为null,如果不是null,说明有等待同步状态的线程,就会尝试唤醒head节点,使其重新竞争同步状态。
3.3 独占式同步状态的获取
独占式的意思就是说同一时间只能有一个线程获得同步状态。
AQS会先尝试调用实现类的tryAcquire方法获取同步状态,如果获取失败,会尝试将其封装为Node节点添加到同步队列尾部。
独占式同步状态的获取通过AQS的acquire方法实现。其源码如下:
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
这个方法会先尝试获取一次同步状态(tryAcquire),如果获取失败,会通过addWaiter方法将当前线程加入到同步队列。 并在acquireQueued方法中将当前线程阻塞(LockSupport.park()),并进入自旋状态,以获取同步状态。
下面具体看一下他是如何构建Node并将其添加到队尾的。 首先是addWaiter:
/**
* Creates and enqueues node for current thread and given mode.
*
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* @return the new node
*/
private Node addWaiter(Node mode) {
// mode = Node.EXCLUSIVE,表示是独占模式
Node node = new Node(Thread.currentThread(), mode);
// 先快速的通过CAS的方式将Node添加到队尾,如果失败,再进入enq方法通过无限循环添加
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
/**
* Inserts node into queue, initializing if necessary. See picture above.
* @param node the node to insert
* @return node's predecessor
*/
private Node enq(final Node node) {
// 无限循环的将node添加到队尾,保证能添加成功
/*
注意:如果是首次向队列中添加Node,那么调addWaiter方法时,tail还是null,所以addWaiter方法不会设置成功,会直接进入这个方法
进入这个方法后,由于tail仍然是null,所以会走到第一个if里面,这是会创建一个空的Node出来作为头结点
然后再次循环,此时tail不是null了,会进入else的代码中,这时,才会将需要add的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;
}
}
}
}
再看下acquireQueued方法:
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
// 进入自旋,不断的获取同步状态
for (;;) {
// 获取node在队列中的前驱节点
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
// 如果成功进入到这块代码,说明成功的获取了同步状态
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 获取不成功,调用LockSupport.park()方法将当前线程阻塞
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
shouldParkAfterFailedAcquire方法用户判断是否需要阻塞当前线程,方法内会操作当前队尾节点的前驱节点的waitStatus,并依据waitStatus判断是否需要park。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL) // Node.SIGNAL == -1
/*
* 表明当前节点需要其他线程的唤醒才能继续执行,此时可以安全的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=0时,
* 将前驱节点的waitStatus设置为-1,表明其需要别的线程唤醒才能继续执行
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
当shouldParkAfterFailedAcquire方法判断当前节点需要被park时,会调用parkAndCheckInterrupt将其阻塞:
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
3.4 独占式同步状态的释放
独占式的同步状态释放,在AQS中是通过release()方法实现的。此方法源码如下:
public final boolean release(int arg) {
// 尝试调用实现类的tryRelease方法来修改同步状态(state)
if (tryRelease(arg)) {
Node h = head;
/*
1.如果head节点是null,表示没有其他线程竞争同步状态,直接返回释放成功
2.如果head节点不是null,表明有竞争。通过unparkSuccessor方法,通过unpark方法唤醒head节点的next节点。使其重新尝试竞争同步状态。
*/
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
unparkSuccessor方法会唤醒head节点的next节点,使其可以重新竞争同步状态:
private void unparkSuccessor(Node node) {
/*
* 如果waitStatus的值是负数,例如:-1(等待signal)
* 则将其值还原为0
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* 获取头结点的next节点,如果非空,则unpark他
*/
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);
}