一、概述
AbstractQueuedSynchronizer类翻译为抽象队列同步器， 提供了一个基于FIFO队列，可以用于构建锁或者其他相关同步装置的基础框架，也是一个Java提供的底层同步工具类，用一个int类型的变量state表示同步状态，并提供了一系列的CAS操作来管理这个同步状态。AQS的主要作用是为Java中的并发同步组件提供统一的底层支持，比如 ReentrantLock、CountDownLatch 和 Semaphore 等都是基于AQS实现的，因此学习AQS的使用与源码实现对深入理解concurrent包中的类有非常大的帮助。
二、源码分析
1. 类的声明
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.SerializableAbstractQueuedSynchronizer类继承自AbstractOwnableSynchronizer抽象类，并且实现了Serializable接口，可以进行序列化。
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;
}
}AbstractOwnableSynchronizer抽象类中，定义了设置独占资源线程和获取独占资源线程的方法，这两个方法会在子类中调用。
2. 成员变量
//序列化标识id
private static final long serialVersionUID = 7373984972572414691L;
//等待队列的volatile修饰的原子性头结点
private transient volatile Node head;
//等待队列的尾结点
private transient volatile Node tail;
//状态
private volatile int state;
//默认自旋上限时间
static final long spinForTimeoutThreshold = 1000L;
//Unsafe类的实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
//state内存偏移量
private static final long stateOffset;
//head结点的内存便宜量
private static final long headOffset;
//tail结点的内存偏移量
private static final long tailOffset;
//waitStatus等待状态的内存偏移量
private static final long waitStatusOffset;
//下一个结点的内存偏移量
private static final long nextOffset;成员变量中定义了头结点head，尾结点tail，状态state、自旋时间spinForTimeoutThreshold，还有AbstractQueuedSynchronizer抽象的属性在内存中的偏移地址。
3. 静态代码块
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"));
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("next"));
} catch (Exception ex) { throw new Error(ex); }
}静态代码块作用是获取成员变量声明的那几个偏移地址，通过该偏移地址，可以获取和设置该属性的值。
4. 构造函数
protected AbstractQueuedSynchronizer() { }构造函数为从抽象构造函数，供子类调用。
5. 内部类-Node类
static final class Node {
// 结点类型，分为共享模式与模式
// 共享模式
static final Node SHARED = new Node();
// 独占模式
static final Node EXCLUSIVE = null;
// 结点状态
// 值为0，表示当前节点在sync队列中，等待着获取锁
// CANCELLED，值为1，表示当前的线程被取消
static final int CANCELLED = 1;
// SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark
static final int SIGNAL = -1;
// CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列中
static final int CONDITION = -2;
// PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行
static final int PROPAGATE = -3;
// 结点状态
volatile int waitStatus;
// 前驱结点
volatile Node prev;
// 后继结点
volatile Node next;
// 结点所对应的线程
volatile Thread thread;
// 下一个等待者
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;
}
}6. 内部类-ConditionObject类
ConditionObject类为AQS引入了条件变量的概念，能够实现线程在条件队列与等待队列之间的转换。每个条件变量都会有两个方法，唤醒和等待：当条件满足时，我们就会通过唤醒方法将条件容器内的线程放入同步队列中；如果不满足条件，我们就会通过等待方法将线程阻塞然后放入条件队列中。
public class ConditionObject implements Condition, java.io.Serializable {
//序列化标识id
private static final long serialVersionUID = 1173984872572414699L;
//条件队列的头结点
private transient Node firstWaiter;
//条件队列的尾结点
private transient Node lastWaiter;
//无参构造
public ConditionObject() { }
//添加结点到条件队列中
private Node addConditionWaiter() {
//把节点t指向lastWaiter
Node t = lastWaiter;
//lastWaiter不是null且它的等待状态不是CONDITION，说明lastWaiter的状态是CANCELLED
if (t != null && t.waitStatus != Node.CONDITION) {
//通过unlinkCancelledWaiters方法来移除条件队列中所有CANCELLED的节点
unlinkCancelledWaiters();
//将t指向新的lasterWaiter
t = lastWaiter;
}
//将当前线程包装成一个节点，但是与同步队列初始化节点时不同，条件队列新建节点时会把状态置为CONDITION，而同步队列则是默认值0，所以条件队列中的节点只有CONDITION和CANCELLED两种状态。
Node node = new Node(Thread.currentThread(), Node.CONDITION);
//判断尾结点是否为null，为null说明条件队列为空
if (t == null)
//将firstWaiter指向新的节点
firstWaiter = node;
//如果不为null，就将尾结点的后继节点指向新节点
else
t.nextWaiter = node;
//重置lastWaiter
lastWaiter = node;
//将新节点返回
return node;
}
//转移条件队列中的第一个状态不为CANNCELLED的Node
private void doSignal(Node first) {
do {
//将firstWaiter指向first的后继节点，然后判断first的后继节点是否为空
if ( (firstWaiter = first.nextWaiter) == null)
/如果为空，则说明条件队列中只有first这一个节点，所以我们将整个队列清空，即将lastWaiter = null
lastWaiter = null;
//再将first的的nextWaiter指向null
first.nextWaiter = null;
//首先调用transferForSignal，如果返回为false，说明节点进入同步队列失败（已经被取消了），则我们会判断此节点的下一个节点是否为null，即(first = firstWaiter) != null) ，如果不为null，则会再次进入循环将这个节点进行入队，否则就不会进入到循环队列了；当然，如果transferForSignal返回true，则说明此节点入队成功了，则我们就会退出循环了
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
//将条件队列中的所有Node移到同步队列中
private void doSignalAll(Node first) {
lastWaiter = firstWaiter = null;
do {
//将next指向first的后继Node
Node next = first.nextWaiter;
//切断first与后继Node的联系
first.nextWaiter = null;
//将此node转移到同步队列中
transferForSignal(first);
//将first指向first的后继Node
first = next;
//在判断此时的first是否为null，不是则继续循环
} while (first != null);
}
//将条件队列中所有状态不为CONDITION的的节点移除
private void unlinkCancelledWaiters() {
Node t = firstWaiter;
Node trail = null;
while (t != null) {
Node next = t.nextWaiter;
if (t.waitStatus != Node.CONDITION) {
t.nextWaiter = null;
if (trail == null)
firstWaiter = next;
else
trail.nextWaiter = next;
if (next == null)
lastWaiter = trail;
}
else
trail = t;
t = next;
}
}
//转移条件队列中的第一个状态不为CANNCELLED的Node
public final void signal() {
//通过子类重写的isHeldExclusively()方法判断是否获取到了锁，只有获得了锁的线程才能够去唤醒条件队列中的Node。
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
//判断条件队列的头结点是否为null，为null则说明条件队列中没有阻塞的Node；如果不为null，则会通过doSignal方法来将条件队列中的Node移动到同步队列中
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
//转移条件队列中所有状态不为CANNCELLED的Node
public final void signalAll() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignalAll(first);
}
//不支持中断的条件等待
public final void awaitUninterruptibly() {
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
boolean interrupted = false;
while (!isOnSyncQueue(node)) {
LockSupport.park(this);
if (Thread.interrupted())
interrupted = true;
}
if (acquireQueued(node, savedState) || interrupted)
selfInterrupt();
}
//wait方法退出时，会重新再中断一次
private static final int REINTERRUPT = 1;
//代表wait方法退出时，会抛出InterruptedException异常
private static final int THROW_IE = -1;
//如果中断先于其他线程调用signal等方法唤醒的，则应该返回THROW_IE，而中断是后于其他线程调用signal等方法唤醒，则返回REINTERRUPT
private int checkInterruptWhileWaiting(Node node) {
return Thread.interrupted() ?
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
0;
}
//对中断进行处理
private void reportInterruptAfterWait(int interruptMode)
throws InterruptedException {
//如果是THROW_IE，就是抛异常
if (interruptMode == THROW_IE)
throw new InterruptedException();
//如果是REINTERRUPT，就再自我中断一次
else if (interruptMode == REINTERRUPT)
selfInterrupt();
}
//将节点加入条件队列并阻塞，等到其他线程唤醒(signal)或者自身中断后再重新去获取锁
public final void await() throws InterruptedException {
//如果此线程被中断过，直接抛中断异常
if (Thread.interrupted())
throw new InterruptedException();
//将当前线程包装成节点放入条件队列
Node node = addConditionWaiter();
//释放当前线程持有的锁
int savedState = fullyRelease(node);
//初始化中断模式参数
int interruptMode = 0;
//检查节点是否在同步队列中
while (!isOnSyncQueue(node)) {
// 不在同步队列中则阻塞此线程
LockSupport.park(this);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
//被唤醒后再去获取锁
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
//当线程是被中断唤醒时，node和后继节点是没有断开的
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
//根据异常标志位对异常进行处理
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
//指定时间的条件等待，在await()的基础上加了指定的等待时间
public final long awaitNanos(long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
final long deadline = System.nanoTime() + nanosTimeout;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
transferAfterCancelledWait(node);
break;
}
if (nanosTimeout >= spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return deadline - System.nanoTime();
}
//指定绝对的时间条件等待
public final boolean awaitUntil(Date deadline)
throws InterruptedException {
long abstime = deadline.getTime();
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (System.currentTimeMillis() > abstime) {
timedout = transferAfterCancelledWait(node);
break;
}
LockSupport.parkUntil(this, abstime);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return !timedout;
}
//指定时间的条件等待
public final boolean await(long time, TimeUnit unit)
throws InterruptedException {
long nanosTimeout = unit.toNanos(time);
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
final long deadline = System.nanoTime() + nanosTimeout;
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
timedout = transferAfterCancelledWait(node);
break;
}
if (nanosTimeout >= spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return !timedout;
}
//如果condition是指定的同步对象创建的，则返回true
final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {
return sync == AbstractQueuedSynchronizer.this;
}
//查询是否有线程等待在当前condition上
protected final boolean hasWaiters() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
if (w.waitStatus == Node.CONDITION)
return true;
}
return false;
}
//查询等待在condition上的线程数量的估计值
protected final int getWaitQueueLength() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int n = 0;
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
if (w.waitStatus == Node.CONDITION)
++n;
}
return n;
}
//返回可能等待在condition上的线程集合
protected final Collection<Thread> getWaitingThreads() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
ArrayList<Thread> list = new ArrayList<Thread>();
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
if (w.waitStatus == Node.CONDITION) {
Thread t = w.thread;
if (t != null)
list.add(t);
}
}
return list;
}
}简单来说，ConditionObject类定义了条件变量，每个条件变量都会有两个方法，唤醒和等待。当条件满足时，我们就会通过唤醒方法将条件容器内的线程放入同步队列中；如果不满足条件，我们就会通过等待方法将线程阻塞然后放入条件队列中。
7. 独占锁的获取
总体流程如下：
步骤代码如下：
/**
* 获取独占锁，对中断不敏感。
* 首先尝试获取一次锁，如果成功，则返回；
* 否则会把当前线程包装成Node插入到队列中，在队列中会检测是否为head的直接后继，并尝试获取锁,
* 如果获取失败，则会通过LockSupport阻塞当前线程，直至被释放锁的线程唤醒或者被中断，随后再次尝试获取锁，如此反复。
*/
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
/**
* 在队列中新增一个节点。
*/
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
// 快速尝试
if (pred != null) {
node.prev = pred;
// 通过CAS在队尾插入当前节点
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 初始情况或者在快速尝试失败后插入节点
enq(node);
return node;
}
/**
* 通过循环+CAS在队列中成功插入一个节点后返回。
*/
private Node enq(final Node node) {
for (;;) {
Node t = tail;
// 初始化head和tail
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
} else {
/*
* AQS的精妙就是体现在很多细节的代码，比如需要用CAS往队尾里增加一个元素
* 此处的else分支是先在CAS的if前设置node.prev = t，而不是在CAS成功之后再设置。
* 一方面是基于CAS的双向链表插入目前没有完美的解决方案，另一方面这样子做的好处是：
* 保证每时每刻tail.prev都不会是一个null值，否则如果node.prev = t
* 放在下面if的里面，会导致一个瞬间tail.prev = null，这样会使得队列不完整。
*/
node.prev = t;
// CAS设置tail为node，成功后把老的tail也就是t连接到node。
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
/**
* 在队列中的节点通过此方法获取锁，对中断不敏感。
*/
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
/*
* 检测当前节点前驱是否head，这是试获取锁的资格。
* 如果是的话，则调用tryAcquire尝试获取锁,
* 成功，则将head置为当前节点。
*/
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
/*
* 如果未成功获取锁则根据前驱节点判断是否要阻塞。
* 如果阻塞过程中被中断，则置interrupted标志位为true。
* shouldParkAfterFailedAcquire方法在前驱状态不为SIGNAL的情况下都会循环重试获取锁。
*/
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
/**
* 根据前驱节点中的waitStatus来判断是否需要阻塞当前线程。
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* 前驱节点设置为SIGNAL状态，在释放锁的时候会唤醒后继节点，
* 所以后继节点（也就是当前节点）现在可以阻塞自己。
*/
return true;
if (ws > 0) {
/*
* 前驱节点状态为取消,向前遍历，更新当前节点的前驱为往前第一个非取消节点。
* 当前线程会之后会再次回到循环并尝试获取锁。
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/**
* 等待状态为0或者PROPAGATE(-3)，设置前驱的等待状态为SIGNAL,
* 并且之后会回到循环再次重试获取锁。
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
/**
* 该方法实现某个node取消获取锁。
*/
private void cancelAcquire(Node node) {
if (node == null)
return;
node.thread = null;
// 遍历并更新节点前驱，把node的prev指向前部第一个非取消节点。
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// 记录pred节点的后继为predNext，后续CAS会用到。
Node predNext = pred.next;
// 直接把当前节点的等待状态置为取消,后继节点即便也在cancel可以跨越node节点。
node.waitStatus = Node.CANCELLED;
/*
* 如果CAS将tail从node置为pred节点了
* 则剩下要做的事情就是尝试用CAS将pred节点的next更新为null以彻底切断pred和node的联系。
* 这样一来就断开了pred与pred的所有后继节点，这些节点由于变得不可达，最终会被回收掉。
* 由于node没有后继节点，所以这种情况到这里整个cancel就算是处理完毕了。
*
* 这里的CAS更新pred的next即使失败了也没关系，说明有其它新入队线程或者其它取消线程更新掉了。
*/
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
// 如果node还有后继节点，这种情况要做的事情是把pred和后继非取消节点拼起来。
int ws;
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
/*
* 如果node的后继节点next非取消状态的话，则用CAS尝试把pred的后继置为node的后继节点
* 这里if条件为false或者CAS失败都没关系，这说明可能有多个线程在取消，总归会有一个能成功的。
*/
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
/*
* 这时说明pred == head或者pred状态取消或者pred.thread == null
* 在这些情况下为了保证队列的活跃性，需要去唤醒一次后继线程。
* 举例来说pred == head完全有可能实际上目前已经没有线程持有锁了，
* 自然就不会有释放锁唤醒后继的动作。如果不唤醒后继，队列就挂掉了。
*
* 这种情况下看似由于没有更新pred的next的操作，队列中可能会留有一大把的取消节点。
* 实际上不要紧，因为后继线程唤醒之后会走一次试获取锁的过程，
* 失败的话会走到shouldParkAfterFailedAcquire的逻辑。
* 那里面的if中有处理前驱节点如果为取消则维护pred/next,踢掉这些取消节点的逻辑。
*/
unparkSuccessor(node);
}
/*
* 取消节点的next之所以设置为自己本身而不是null,
* 是为了方便AQS中Condition部分的isOnSyncQueue方法,
* 判断一个原先属于条件队列的节点是否转移到了同步队列。
*
* 因为同步队列中会用到节点的next域，取消节点的next也有值的话，
* 可以断言next域有值的节点一定在同步队列上。
*
* 在GC层面，和设置为null具有相同的效果。
*/
node.next = node;
}
}
/**
* 唤醒后继线程。
*/
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
// 尝试将node的等待状态置为0,这样的话,后继争用线程可以有机会再尝试获取一次锁。
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
/*
* 这里的逻辑就是如果node.next存在并且状态不为取消，则直接唤醒s即可
* 否则需要从tail开始向前找到node之后最近的非取消节点。
*
* 这里为什么要从tail开始向前查找也是值得琢磨的:
* 如果读到s == null，不代表node就为tail，参考addWaiter以及enq函数中的我的注释。
* 不妨考虑到如下场景：
* 1. node某时刻为tail
* 2. 有新线程通过addWaiter中的if分支或者enq方法添加自己
* 3. compareAndSetTail成功
* 4. 此时这里的Node s = node.next读出来s == null，但事实上node已经不是tail，它有后继了!
*/
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);
}8. 独占锁的释放
public final boolean release(int arg) {
if (tryRelease(arg)) {
/*
* 此时的head节点可能有3种情况:
* 1. null (AQS的head延迟初始化+无竞争的情况)
* 2. 当前线程在获取锁时new出来的节点通过setHead设置的
* 3. 由于通过tryRelease已经完全释放掉了独占锁，有新的节点在acquireQueued中获取到了独占锁，并设置了head
* 第三种情况可以再分为两种情况：
* （一）时刻1:线程A通过acquireQueued，持锁成功，set了head
* 时刻2:线程B通过tryAcquire试图获取独占锁失败失败，进入acquiredQueued
* 时刻3:线程A通过tryRelease释放了独占锁
* 时刻4:线程B通过acquireQueued中的tryAcquire获取到了独占锁并调用setHead
* 时刻5:线程A读到了此时的head实际上是线程B对应的node
* （二）时刻1:线程A通过tryAcquire直接持锁成功，head为null
* 时刻2:线程B通过tryAcquire试图获取独占锁失败失败，入队过程中初始化了head，进入acquiredQueued
* 时刻3:线程A通过tryRelease释放了独占锁，此时线程B还未开始tryAcquire
* 时刻4:线程A读到了此时的head实际上是线程B初始化出来的傀儡head
*/
Node h = head;
// head节点状态不会是CANCELLED，所以这里h.waitStatus != 0相当于h.waitStatus < 0
if (h != null && h.waitStatus != 0)
// 唤醒后继线程，此函数在acquire中已经分析过，不再列举说明
unparkSuccessor(h);
return true;
}
return false;
}对于释放一个独占锁，首先会调用tryRelease，在完全释放掉独占锁后，这时后继线程是可以获取到独占锁的，因此释放者线程需要做的事情是唤醒一个队列中的后继者线程，让它去尝试获取独占锁。完全释放掉锁的含义，简单来说就是当前锁处于无主状态，等待线程有可能可以获取。 比如：对于可重入锁ReentrantLock，每次tryAcquire后，state会+1，每次tryRelease后，state会-1，如果state变为0了，则此时称独占锁被完全释放了。
9. 共享锁的获取
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
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);
}
}
/**
* 这个函数做的事情有两件:
* 1. 在获取共享锁成功后，设置head节点
* 2. 根据调用tryAcquireShared返回的状态以及节点本身的等待状态来判断是否要需要唤醒后继线程。
*/
private void setHeadAndPropagate(Node node, int propagate) {
// 把当前的head封闭在方法栈上，用以下面的条件检查。
Node h = head;
setHead(node);
/*
* propagate是tryAcquireShared的返回值，这是决定是否传播唤醒的依据之一。
* h.waitStatus为SIGNAL或者PROPAGATE时也根据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())
doReleaseShared();
}
}
/**
* 这是共享锁中的核心唤醒函数，主要做的事情就是唤醒下一个线程或者设置传播状态。
* 后继线程被唤醒后，会尝试获取共享锁，如果成功之后，则又会调用setHeadAndPropagate,将唤醒传播下去。
* 这个函数的作用是保障在acquire和release存在竞争的情况下，保证队列中处于等待状态的节点能够有办法被唤醒。
*/
private void doReleaseShared() {
/*
* 以下的循环做的事情就是，在队列存在后继线程的情况下，唤醒后继线程；
* 或者由于多线程同时释放共享锁由于处在中间过程，读到head节点等待状态为0的情况下，
* 虽然不能unparkSuccessor，但为了保证唤醒能够正确稳固传递下去，设置节点状态为PROPAGATE。
* 这样的话获取锁的线程在执行setHeadAndPropagate时可以读到PROPAGATE，从而由获取锁的线程去释放后继等待线程。
*/
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);
}
// 如果h节点的状态为0，需要设置为PROPAGATE用以保证唤醒的传播。
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
// 检查h是否仍然是head，如果不是的话需要再进行循环。
if (h == head)
break;
}
}与获取独占锁的实现不同的关键在于，共享锁允许多个线程持有。如果需要使用AQS中的共享锁，在实现tryAcquireShared方法时需要注意，返回负数表示获取失败;返回0表示成功，但是后继争用线程不会成功;返回正数表示获取成功，并且后继争用线程也可能成功。
10. 共享锁的释放
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
// doReleaseShared的实现上面获取共享锁已经介绍
doReleaseShared();
return true;
}
return false;
}释放共享锁与获取共享锁的代码共享了doReleaseShared()方法，用于实现唤醒的传播。
三、总结
AbstractQueuedSynchronizer类的功能可以分为两类：独占锁和共享锁，它的所有子类中，要么实现并使用了它独占锁的API，要么使用了共享锁的API。它的子类ReentrantReadWriteLock类，也是通过两个内部类：读锁和写锁，分别实现的两套API来实现的。
AbstractQueuedSynchronizer类设计基于模板方法模式，开发者需要继承同步器并且重写指定的方法，将其组合在并发组件的实现中，调用同步器的模板方法，模板方法会调用使用者重写的方法。
AbstractQueuedSynchronizer类的内部设计大致如下：
1. 内部维护一个CLH队列来管理锁。
2. 线程会首先尝试获取锁，如果失败，则将当前线程以及等待状态等信息包成一个Node节点加到同步队列里。
3. 接着会不断循环（自旋）尝试获取锁（条件是当前节点为head的直接后继才会尝试），如果失败则会阻塞自己，直至被唤醒。
4. 当持有锁的线程释放锁时，会唤醒队列中的后继线程。
更多精彩内容，敬请扫描下方二维码，关注我的微信公众号【Java觉浅】，获取第一时间更新哦！