AQS的核心思想
如果当前共享资源是空闲的,那么便会将请求资源的这个线程设为工作线程,并把资源的状态设置为锁定状态;如果资源正在被占用,那么就将请求的线程加入到工作队列(CLH队列中),等待唤醒。
CLH队列结构
CLH队列通常用于spinLock,也就是自旋锁。
CLH队列中每一个节点都是一个AQS.Node。
AQS.Node类
static final class Node {
// 用于指示当前节点在共享模式下阻塞,等待执行 (Marker to indicate a node is waiting in shared mode)
static final Node SHARED = new Node();
// 用于指示当前节点在独占模式下阻塞,等待执行
static final Node EXCLUSIVE = null;
// 表示Node包含的线程已经被取消了调度,状态永远不会再被改变
static final int CANCELLED = 1;
// Node的【后继节点】处于或即将处于阻塞状态,当前Node在执行后,需要对后继节点执行unpark操作来唤醒后继节点。也就是说,后继节点是在等待当前的节点来唤醒它的(节点入队时,会将前继节点的waitStatus设定为SIGNAL)
static final int SIGNAL = -1;
// 表明该Node节点在条件队列当中,当其它线程调用了Condition的signal方法之后,当前节点会从等待队列转移到同步队列,等待着获取同步锁。
static final int CONDITION = -2;
// 表明releaseShared应该传播到其它节点。 在doReleaseShared中对此进行了设置(仅适用于头节点),以确保传播继续进行,即使此后进行了其他操作(官方文档直接翻译来的)。
// 也就是说,共享模式下,当前节点被唤醒时,会唤醒后面的所有的共享节点。
static final int PROPAGATE = -3;
// 取值为 CANCELLED、SIGNAL、CONDITION或PROPAGATE
// 如果不是以上几种,则设定为0
volatile int waitStatus;
// 指向在CLH队列中的前、后节点
volatile Node prev;
volatile Node next;
// Node代表的线程
volatile Thread thread;
// 链接到下一个条件节点,或者具有特殊值SHARED的节点
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() { // Used to establish initial head or SHARED marker
}
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) { // Used by Condition
this.waitStatus = waitStatus;
this.thread = thread;
}
}
AQS类的一些重要的字段
private volatile int state:同步状态(The synchronization state)(Exclusive和Share两种状态,分别来表明是独占的,还是共享的)
private transient volatile Node head:指向CLH队列的头节点
private transient volatile Node tail:指向CLH队列的尾节点
部分方法预览
private Node enq(final Node node):将Node插入CLH队列
private Node addWaiter(Node mode):为当前线程创建指定mode(Node.EXCLUSIVE 或 Node.SHARED)的Node,并加入CLH队列(Creates and enqueues node for current thread and given mode)
private void unparkSuccessor(Node node):唤醒node的后继节点
private void doReleaseShared():shared mode下的释放操作
private void cancelAcquire(Node node):取消正在执行acquire的操作
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node):检查并且更新 执行acquire操作 失败的node的status
protected boolean tryAcquire(int arg) :排它模式exclusive下使用,尝试在排它模式下获取共享资源
protected boolean tryRelease(int arg):在exclusive模式下,尝试执行release共享资源操作
protected int tryAcquireShared(int arg):在shared模式下,尝试执行acquire共享资源操作
protected boolean tryReleaseShared(int arg):在shared模式下,尝试执行release共享资源操作
protected boolean isHeldExclusively():判断一个线程是否正在独占资源,括号后面的异常表明只能用于用到condition的情况(UnsupportedOperationException if conditions are not supported)
public final void acquire(int arg) :exclusive模式下获取共享资源,ignoring interrupts
public final void acquireInterruptibly(int arg):exclusive模式下获取共享资源,但是会aborting if interrupted
public final boolean release(int arg):exclusive模式下的释放操作
public final void acquireShared(int arg):shared模式下的获取操作,ignoring interrupts
public final void acquireSharedInterruptibly(int arg):shared模式下的获取操作,但是会aborting if interrupted
public final boolean releaseShared(int arg) :shared模式下的释放操作
public final boolean isQueued(Thread thread):判断一个线程是否已经在CLH队列中
public final Collection<Thread> getQueuedThreads():获取队列中的所有的等待线程
public final Collection<Thread> getExclusiveQueuedThreads() :获取队列中所有的exclusive模式下的等待线程
public final Collection<Thread> getSharedQueuedThreads():获取队列中所有的shared模式下的等待线程
final boolean transferForSignal(Node node):将一个Node从condition队列转到同步队列中
一些源码
Node入CLH队列:该方法采用了自旋操作
将Node加入CLH队列的时候,如果未进行初始化,则需要进行初始化。如果已初始化,则将Node接到CLH队列的尾部,并将tail指针指向当前加入的Node。返回的是插入的节点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;
}
}
}
}
enq方法中涉及到两个采用CAS机制的方法,compareAndSetHead和compareAndSetTail
/**
* CAS head field. Used only by enq.
*/
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}
/**
* CAS tail field. Used only by enq.
*/
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
AQS.addWaiter:以SHARED或EXCLUSIVE模式为当前线程创建节点,并加入 CLH 队列
在加入的时候,先假定CLH并未等待执行的任务。若无,通过CAS保证添加到CLH尾部,否则调用enq方法加入。
private Node addWaiter(Node mode) {
// 以特定模式为当前线程创建CLH节点
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
// CLH 中包含其它节点时
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// CLH中不包含其它节点,
enq(node);
return node;
}
AQS.unparkSuccessor:唤醒node的后继节点(如果存在)
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
// 如果后继节点为null或者后继节点的执行为CANCELLED状态
// 则从 CLH 尾部向前遍历,找到一个可以唤醒的前继节点
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);
}
// CAS next field of a node.
private static final boolean compareAndSetWaitStatus(Node node,
int expect,
int update) {
return unsafe.compareAndSwapInt(node, waitStatusOffset,
expect, update);
}
AQS.doReleaseShared
Release action for shared mode -- signals successor and ensures propagation. (Note: For exclusive mode, release just amounts to calling unparkSuccessor of head if it needs signal.)
共享模式下的释放操作,作用在于唤醒后继节点的线程。
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; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
AQS.acquireQueued
Acquires in exclusive uninterruptible mode for thread already in queue. Used by condition wait methods as well as acquire.
以独占不间断模式获取已在队列中的线程。
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;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}