柳丝榆荚自芳菲，不管桃飘与李飞。
前言
AQS内部维持着一个双向的同步队列，节点状态可以是共享的也可以是独占的。
构造函数
//构造函数为protected，只有子类或者同包下的类才能访问。
protected AbstractQueuedSynchronizer() { }
属性和静态代码块
//同步队列的首结点，延迟初始化。除了初始化之外，它只通过setHead方法进行修改。
//注意:如果head存在，则保证它的status不为cancelled
private transient volatile Node head;
//同步队列的尾结点，延迟初始化。只有通过enq加入新的节点时，才会被修改。
private transient volatile Node tail;
// 同步状态
private volatile int state;
//快速自旋的时间（单位：纳秒），而不是park线程的时间。
//为了提高在短时间内的足够好的响应的一个粗略估计值。
static final long spinForTimeoutThreshold = 1000L;
//获取支持compareAndSet的一些属性
//获取Unsafe实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
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;
static {
try {
//获取AbstractQueuedSynchronizer类的state字段的内存地址偏移量
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
//获取AbstractQueuedSynchronizer类的head字段的内存地址偏移量
headOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
//获取AbstractQueuedSynchronizer类的tail字段的内存地址偏移量
tailOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
//获取Node类的waitStatus字段的内存地址偏移量
waitStatusOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("waitStatus"));
//获取Node类的next字段的内存地址偏移量
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("next"));
} catch (Exception ex) { throw new Error(ex); }
}
private方法
//将队列头设置为节点，从而退出队列。
//只有获取同步状态的方法中才会调用它。
//为了GC和不必要的signal和遍历，将不使用的属性置为null。
//head节点只是获得同步状态的线程通知后继阻塞线程的载体
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}
//CAS的去设置同步队列的head。只在enq方法中使用。
private final boolean compareAndSetHead(Node update) {
//因为head节点是延迟初始化的，所以刚开始是null。
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}
//CAS的设置同步队列的tail。只在enq方法中使用。
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
//CAS的设置node的next属性
private static final boolean compareAndSetNext(Node node,
Node expect,
Node update) {
return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
}
//CAS的去设置Node的status属性。
private static final boolean compareAndSetWaitStatus(Node node,
int expect,
int update) {
//waitStatusOffset表示node对象status在内存中的地址偏移量
return unsafe.compareAndSwapInt(node, waitStatusOffset,
expect, update);
}
//将节点加入到同步队列中
//返回插入的节点在同步队列中的前一个节点
//同步队列是一个双向队列
private Node enq(final Node node) {
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;
}
}
}
}
//构建指定类型的节点并且加入到同步队列中。
//也可以有共享模式的节点，并且条件队列中的节点是不是也可以有这两种状态？？
//返回一个新的节点
private Node addWaiter(Node mode) {
//mode为Node.EXCLUSIVE表示为独占模式下的节点，
//为Node.SHARED表示共享模式下的节点。
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)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
//从同步队列的尾结点开始自旋寻找，查看当前节点是否在同步队列中，
//如果在同步队队列中，那么返回true。
//本方法只会在isOnSyncQueue方法中调用。
private boolean findNodeFromTail(Node node) {
Node t = tail;
for (;;) {
if (t == node)
return true;
//表示t为头结点的前一个节点
//已经遍历到头结点了，还是没有找到当前节点，那么返回false
if (t == null)
return false;
t = t.prev;
}
}
//如果后继节点存在，则唤醒后继节点。
private void unparkSuccessor(Node node) {
//如果当前节点状态为负值（可能在等待signal）,在被signal之前，
//将节点的状态设置为0。
//如果清除状态失败或者在线程等待的时候，状态被其他线程改变了，
//也没有关系。
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//将要unpark的线程已经保存在后继节点中，一般就是下一个节点。
//但是下一个节点被cancelled或者为空,那么就从后向前遍历同步队列，
//找到non-cancelled的后继节点。
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);
}
//获取同步状态失败之后，检查并更新当前节点的状态。
//如果当前节点的线程应该阻塞，返回true。
//这个方法是循环获取同步状态中的主要信号控制。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//pre当前节点的前一个持有同步状态的节点
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
//这个节点已经设置了前一个节点的状态，让其释放同步状态之后唤醒它。
//那么这个节点可以安全park。
return true;
if (ws > 0) {
//前一个节点被cancelled，所以需要往前遍历,
//直到找到没有被cancelled的节点。
//（相当于删除队列中取消状态的节点）
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//（因为这是同步队列，节点状态不可能为condition）。
//那么进入这个分支之后，当前节点状态只可能为初始化的0或者propagate。
//前一个节点状态为0或者propagate，那么当前节点需要signal，但是不用park。
//调用者需要重新尝试以确保节点在parking之前不能去获取同步状态。
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
//park当前线程，并返回线程的中断状态。
//如果线程被中断了，那么返回true。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
//Thread.interrupted()清除线程的中断标志，并返回清除之前的中断标志。
return Thread.interrupted();
}
//当fastppath失败的时候调用，是getFirstQueuedThread的另一个版本
private Thread fullGetFirstQueuedThread() {
//第一个节点通常是head.next。尝试获取它的线程字段，确保一致读取:如果线程为null
//或者s.prev不再是head，然后在我们去取第一个线程节点的时候，
//其他一些并发地执行setHead。
//在从后遍历之前，我们尝试了两次。
/**
*将头结点赋值给h，将头结点的下一个节点赋值给s。
*下面的检查操作执行了两次
* (
* (h = head) != null && (s = h.next) != null &&
* s.prev == head && (st = s.thread) != null
*)
*/
Node h, s;
Thread st;
if (((h = head) != null && (s = h.next) != null &&
s.prev == head && (st = s.thread) != null) ||
((h = head) != null && (s = h.next) != null &&
s.prev == head && (st = s.thread) != null))
return st;
//如果head的next还没有设置，或者当setHead之后，可能head的next没有设置。
//所以需要检查tail是不是第一个节点。如果不是，那么需要安全地从tail遍历到head，
//找到第一个节点，确保终止。
Node t = tail;
Thread firstThread = null;
while (t != null && t != head) {
Thread tt = t.thread;
if (tt != null)
firstThread = tt;
t = t.prev;
}
return firstThread;
}
//设置同步队列的头结点，检查后继节点，是不是在共享模式中，
//如果是在共享模式下，或者在propagate > 0或者status是propagate，
//那么传播同步状态。
private void setHeadAndPropagate(Node node, int propagate) {
//node将要被设置为头结点的节点
//propagate是tryAcquireShared的返回值。
Node h = head; // Record old head for check below
setHead(node);
//尝试signal队列的下一个节点：
//1.同步状态被调用者传播,或者被前一个操作记录下来
//（在setHead的前后记录状态都是可以的）;
//(对status采用符号校验，因为有可能status从propagate转变为signal)
//2.并且下一个等待的节点是同步模式，
//或者不知道处于什么状态，因为节点看起来是空的。
//只有在多个线程竞争获取/释放同步状态，这两项检查才会导致不必要的唤醒
//大多数线程都需要唤醒。
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
//这里的head已经是新的头结点了
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
//取消正在尝试获取同步状态的节点
private void cancelAcquire(Node node) {
if (node == null)
return;
node.thread = null;
// 跳过已经cancelled的前继节点
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
Node predNext = pred.next;
// 这里使用无条件写而不是CAS。
//在这个原子操作之后，其他线程可以跳过该节点。
//在这个原子操作之前，该节点可以不受其他线程的干扰。
node.waitStatus = Node.CANCELLED;
// 如果当前节点是尾结点，那么将前继节点设置为尾结点。
//并将尾结点的下一个节点设置为null
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
//如果后继节点需要signal，那么尝试设置pred的next-link，让pred有后继者，
//否则，唤醒当前节点,传播同步状态。
int ws;
//1.前继节点不是头结点；
//2.前继节点状态为signal或者<=0并设置前继节点状态为signal成功；
//3.前继节点的线程不为空
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
//唤醒当前节点的后继节点
unparkSuccessor(node);
}
//将当前节点踢出
node.next = node; // help GC
}}
1.独占模式
//独占模式下可中断的获取同步状态。
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
//前继节点是头结点并且当前节点获取同步状态成功
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
//独占模式下指定等待时间的获取同步状态
//指定时间内，获取同步状态成功，返回true。
private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
//前继节点是头结点并且当前节点获取同步状态成功
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
//剩余等待时间
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
//如果当前线程应该阻塞，但是由于时间小于自旋超时时间，
//那么不要去阻塞，直接进行下一次自旋，获取同步状态。
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
2.共享模式
//共享模式下不可中断的获取同步状态
private void doAcquireShared(int arg) {
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;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
//共享模式下可中断的获取同步状态
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
//共享模式下指定时间内获取同步状态
//如果指定时间内获取同步状态成功，返回true。
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return true;
}
}
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
//在共享模式下释放同步状态--唤醒后继者并且传播同步状态
//注意：在独占模式下，如果后继节点需要唤醒，
//释放同步状态就是相当于unpark头结点的后继节点。
private void doReleaseShared() {
//即使有其他正在进行的同步状态的获取/释放，也要确保传播同步状态。
//如果头结点的后继者需要signal，那么unpark后继者。
//如果后继节点不需要signal，当头结点释放同步状态后，
//将自己的状态设置为propagate，以确保同步状态被传播。
//此外，必须将这些操作放在循环中，
//以防我们做这些操作的时候，新的节点被加入进来。
//而且，不像unparkSuccessor其他使用那样，在这里
//需要知道CAS重置状态失败的情况，所以需要重新检查。
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
//如果头结点状态为signal，那么将自己状态修改为0，
//修改成功后，唤醒后继节点。
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;
}
}
嘻嘻，如果文章有错误的地方，麻烦小哥哥小姐姐帮忙指出改正，一起学习，一起交流。
