1 AbstractOwnableSynchronizer抽象类
（1）exclusiveOwnerThread：当前持有独占锁的线程对象。
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;
}
}
2 AbstractQueuedSynchronizer.Node内部类
2.1 AbstractQueuedSynchronizer.Node中的字段
（1）waitStatus：waitStatus大于等于0代表无需唤醒后续节点中的线程对象。同步队列中一个节点中的waitStatus的初始值等于0；条件队列中一个节点中的waitStatus等于-2。
（2）prev：表示同步队列中当前节点的上一个节点。
（3）next：表示同步队列中当前节点的下一个节点。同步队列中一个节点中的next字段等于null并不能说明这个节点是同步队列的尾节点。
（4）thread：线程对象。
（5）nextWaiter：在独占模式中，nextWaiter表示条件队列中当前节点的下一个节点；在共享模式中，nextWaiter等于常量SHARED。
volatile int waitStatus;
volatile Node prev;
volatile Node next;
volatile Thread thread;
Node nextWaiter;
2.2 waitStatus字段的数值
（1）CANCELLED：因为超时或中断，当前节点中的线程对象放弃获取锁。如果一个节点中的waitStatus等于1，这个节点中的线程对象不会被阻塞。
（2）SIGNAL：后续节点中的线程对象已经被阻塞或即将被阻塞，如果当前节点中的线程对象释放锁或放弃获取锁，需要唤醒后续节点中的线程对象。
（3）CONDITION：当前节点处于条件队列中。条件队列中的节点转移到同步队列中，这个节点中的waitStatus会从-2变为0。
（4）PROPAGATE：详见AbstractQueuedSynchronizer源码分析第三部分。
（5）0
static final int CANCELLED = 1;
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
2.3 AbstractQueuedSynchronizer.Node中的其它常量
（1）SHARED：表示一个节点正在共享模式中等待。
（2）EXCLUSIVE：表示一个节点正在独占模式中等待。
static final Node SHARED = new Node();
static final Node EXCLUSIVE = null;
2.4 AbstractQueuedSynchronizer.Node中的构造方法
// 本构造方法可以对同步队列的头节点和Node.SHARED进行初始化
Node() {
}
// 在addWaiter方法中调用本构造方法
Node(Thread thread, Node mode) {
this.nextWaiter = mode;
this.thread = thread;
}
// 在addConditionWaiter方法中调用本构造方法
Node(Thread thread, int waitStatus) {
this.waitStatus = waitStatus;
this.thread = thread;
}
2.5 AbstractQueuedSynchronizer.Node中的其它方法
final boolean isShared() {
return nextWaiter == SHARED;
}
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
3 AbstractQueuedSynchronizer中的字段
AbstractQueuedSynchronizer继承了AbstractOwnableSynchronizer。
（1）head：同步队列的头节点。enq方法可以对头节点进行初始化，setHead方法可以修改头节点。如果头节点不等于null，头节点中的waitStatus不等于1。
（2）tail：同步队列的尾节点。
（3）state：锁的状态。
private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;
4 AbstractQueuedSynchronizer中的acquire方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
我们可以将acquire方法改写成另一种形式。
public final void acquire(int arg) {
// 尝试获取独占锁
if (tryAcquire(arg))
return;
// 为当前线程创建节点，并将这个节点插入到同步队列中
Node node = addWaiter(Node.EXCLUSIVE);
// 当前线程获取独占锁
boolean interrupted = acquireQueued(node, arg);
if (interrupted)
// 恢复当前线程的中断状态
selfInterrupt();
}
4.1 AbstractQueuedSynchronizer中的tryAcquire方法
子类中可以重写tryAcquire方法。
// 尝试获取独占锁
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
4.2 AbstractQueuedSynchronizer中的addWaiter方法
// 为当前线程创建节点，并将这个节点插入到同步队列中
// 传入的mode节点可能是Node.EXCLUSIVE或Node.SHARED
private Node addWaiter(Node mode) {
// 为当前线程创建节点
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
// 如果尾节点不等于null
if (pred != null) {
node.prev = pred;
// node节点尝试入队
if (compareAndSetTail(pred, node)) {
// 运行到这里，说明node节点入队成功
pred.next = node;
return node;
}
}
// 如果尾节点等于null或node节点入队失败，调用enq方法将node节点插入到同步队列中
enq(node);
return node;
}
4.2.1 AbstractQueuedSynchronizer中的enq方法
// 将传入的node节点插入到同步队列中
private Node enq(final Node node) {
// 自旋，直至node节点入队成功
for (;;) {
Node t = tail;
// 运行到这里，存在三种情况
// （1）尾节点等于null，头节点等于null，说明CAS尚未成功
// （2）尾节点等于null，头节点不等于null，说明CAS已经成功、尾节点尚未初始化
// （3）尾节点不等于null，头节点不等于null，说明CAS已经成功、尾节点已经初始化
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 运行到这里，说明尾节点和头节点都不等于null
node.prev = t;
// node节点尝试入队
if (compareAndSetTail(t, node)) {
// 运行到这里，说明node节点入队成功
t.next = node;
// 返回同步队列中原来的尾节点（node节点中的prev字段）
return t;
}
}
}
}
4.3 AbstractQueuedSynchronizer中的acquireQueued方法
// 当前线程获取独占锁
// 传入的node节点是当前线程所在节点
final boolean acquireQueued(final Node node, int arg) {
// failed等于true代表当前线程尚未获取独占锁
// failed等于false代表当前线程已经获取独占锁
boolean failed = true;
try {
// interrupted代表当前线程是否被中断
boolean interrupted = false;
// 自旋，直至当前线程已经获取独占锁或抛出异常
for (;;) {
// 获取当前线程所在节点中的prev字段
final Node p = node.predecessor();
// 如果当前线程所在节点中的prev字段等于头节点，尝试获取独占锁
if (p == head && tryAcquire(arg)) {
// 运行到这里，说明当前线程已经获取独占锁
// 将头节点设为当前线程所在节点，将当前线程所在节点中的线程对象设为null，将当前线程所在节点中的prev字段设为null
setHead(node);
// 将原来的头节点中的next字段设为null
p.next = null; // help GC
failed = false;
return interrupted;
}
// 调用shouldParkAfterFailedAcquire方法判断是否应该阻塞当前线程
// shouldParkAfterFailedAcquire方法返回true，调用parkAndCheckInterrupt方法阻塞当前线程
// shouldParkAfterFailedAcquire方法返回false，继续循环
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
// 运行到这里，要么当前线程已经获取独占锁，要么抛出异常
// 如果抛出异常，调用cancelAcquire方法
if (failed)
cancelAcquire(node);
}
}
4.3.1 AbstractQueuedSynchronizer中的shouldParkAfterFailedAcquire方法
// 判断是否应该阻塞当前线程
// 传入的node节点是当前线程所在节点
// 传入的pred节点是当前线程所在节点中的prev字段
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
// 如果pred节点中的waitStatus等于-1，返回true
if (ws == Node.SIGNAL)
return true;
// 如果pred节点中的waitStatus等于1
if (ws > 0) {
// 将当前线程所在节点中的prev字段设为pred节点前面第一个waitStatus不等于1的节点
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 运行到这里，说明pred节点中的waitStatus等于0或-3
// 尝试将pred节点中的waitStatus设为-1
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
4.3.2 AbstractQueuedSynchronizer中的parkAndCheckInterrupt方法
private final boolean parkAndCheckInterrupt() {
// 阻塞当前线程
LockSupport.park(this);
// 运行到这里，存在两种情况
// （1）其它线程调用了unparkSuccessor方法，unparkSuccessor方法中调用了LockSupport中的unpark方法
// （2）其它线程调用了当前线程的interrupt方法
// interrupted方法会清除当前线程的中断状态
return Thread.interrupted();
}
4.3.3 AbstractQueuedSynchronizer中的cancelAcquire方法
// 传入的node节点是当前线程所在节点
private void cancelAcquire(Node node) {
if (node == null)
return;
node.thread = null;
// 将pred节点和当前线程所在节点中的prev字段设为当前线程所在节点前面第一个waitStatus不等于1的节点
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// 获取pred节点中的next字段，用于之后的CAS操作
Node predNext = pred.next;
node.waitStatus = Node.CANCELLED;
// 如果当前线程所在节点等于尾节点，尝试将尾节点设为pred节点
if (node == tail && compareAndSetTail(node, pred)) {
// 运行到这里，说明已经将尾节点设为pred节点
// 尝试将pred节点中的next字段设为null
compareAndSetNext(pred, predNext, null);
} else {
int ws;
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
// 如果当前线程所在节点中的next字段不等于null并且当前线程所在节点中的next字段中的waitStatus不等于1
if (next != null && next.waitStatus <= 0)
// 尝试将pred节点中的next字段设为当前线程所在节点中的next字段
compareAndSetNext(pred, predNext, next);
} else {
// 唤醒后续节点中的线程对象
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
4.4 AbstractQueuedSynchronizer中的selfInterrupt方法
static void selfInterrupt() {
// 中断当前线程
Thread.currentThread().interrupt();
}
5 AbstractQueuedSynchronizer中的release方法
// release方法的返回值等于tryRelease方法的返回值
public final boolean release(int arg) {
// 尝试释放独占锁
if (tryRelease(arg)) {
Node h = head;
// 运行到这里，说明当前线程已经释放独占锁，此时存在四种情况
// （1）头节点等于null
// （2）头节点中的线程对象等于null
// （3）头节点中的线程对象等于当前线程
// （4）头节点中的线程对象等于其它线程
// 如果头节点不等于null并且头节点中的waitStatus小于0
if (h != null && h.waitStatus != 0)
// 唤醒后续节点中的线程对象
unparkSuccessor(h);
return true;
}
return false;
}
5.1 AbstractQueuedSynchronizer中的tryRelease方法
子类中可以重写tryRelease方法。
// 尝试释放独占锁
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
5.2 AbstractQueuedSynchronizer中的unparkSuccessor方法
// 唤醒后续节点中的线程对象
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
// 如果node节点中的waitStatus小于0
if (ws < 0)
// 尝试将node节点中的waitStatus设为0
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
// 如果node节点中的next字段不等于null并且node节点中的next字段中的waitStatus不等于1，直接唤醒node节点中的next字段中的线程对象
// 如果node节点中的next字段等于null或node节点中的next字段中的waitStatus等于1，找到node节点后面第一个waitStatus不等于1的节点并且唤醒这个节点中的线程对象
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);
}
6 AbstractQueuedSynchronizer中的hasQueuedPredecessors方法
// 判断其它线程所在节点是否入队成功
public final boolean hasQueuedPredecessors() {
// 运行到这里，存在三种情况
// （1）尾节点等于null，头节点等于null
// （2）尾节点等于null，头节点不等于null
// （3）尾节点不等于null，头节点不等于null
// 必须先获取尾节点，再获取头节点
Node t = tail;
Node h = head;
Node s;
// 如果头节点等于尾节点，返回false
// 如果头节点不等于尾节点并且头节点中的next字段等于null，说明其它线程所在节点入队成功，返回true
// 如果头节点不等于尾节点并且头节点中的next字段中的线程对象等于当前线程，返回false
// 如果头节点不等于尾节点并且头节点中的next字段中的线程对象等于其它线程，返回true
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
