Java中AQS（AbstractQueuedSynchronizer，队列同步器）是构建JUC中锁和其他同步组件的基础组件，我们在日常开发中一般不会直接与AQS打交道。AQS核心功能就2点，通过CAS维护state状态，通过CAS维护同步队列进而控制线程的阻塞唤醒。换句话说就是：
AQS使用一个int成员变量(
private volatile int state)表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作，并发包的作者（Doug Lea）期望它能够成为实现大部分同步需求的基础。
AQS是一个抽象类，但是并没有抽象方法，只不过有些方法是会抛出UnsupportedOperationException，这些方法就需要根据不同场景进行子类重写，比如可重入锁NonReentrantLock就重写了方法tryRelease、isHeldExclusively、tryAcquire等，子类重写这些方法可自定义对应逻辑，比如判断是否可重入、是否公平设置state等，这块具体代码参考FairSync、NonfairSync类源码即可。
目前AQS的实现类如下所示：
state状态更新
AQS实现类中，必不可少的要对同步状态state进行更改，如果想线程安全的更新数据，只有通过锁或者CAS机制来保证，由于AQS是实现锁的底层组件，因此这里只能使用CAS机制来保证，AQS确实也是这么做的。AQS提供了2个方法来更新状态，compareAndSetState(int expect,int update)和setState(int newState)，后者只有在当前线程是状态占用线程下才能被调用。
子类推荐被定义为自定义同步组件的静态内部类，同步器自身没有实现任何同步接口，它仅仅是定义了若干同步状态获取和释放的方法来供自定义同步组件使用，同步器既可以支持独占式地获取同步状态，也可以支持共享式地获取同步状态，这样就可以方便实现不同类型的同步组件（ReentrantLock、ReentrantReadWriteLock和CountDownLatch等）。
AQS是实现锁（也可以是任意同步组件）的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。可以这样理解二者之间的关系：锁是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程并行访问），隐藏了实现细节；同步器面向的是锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。锁和同步器很好地隔离了使用者和实现者所需关注的领域。
同步队列维护
如果线程更新状态（tryAcquire）成功，直接返回。
如果更细状态失败，则会初始化一个当前的Node对象，CAS设置到同步队列tail。注意队列head、tail节点是懒初始化的。
注意，添加Node对象到同步队列中还不够，因为可能这个时候之前占用状态的线程已经释放状态了，或者后续占用状态的线程释放时，应该怎么唤醒下一个节点线程呢？这里就涉及到再次tryAcquire或者设置当前阻塞Node前一个Node的waitStatus，具体代码可参考方法java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireQueued。
最后就是调用方法LockSupport.park(this)来阻塞当前线程。
源码分析
了解了AQS的state和同步队列后，下面来以类ReentrantLock中FairSync为例来分析AQS流程，示例代码如下：
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
new Thread(() -> {
lock.lock();
System.out.println(Thread.currentThread().getName() + " lock ok");
lock.unlock();
}, "t1").start();
new Thread(() -> {
lock.lock();
System.out.println(Thread.currentThread().getName() + " lock ok");
lock.unlock();
}, "t2").start();
LockSupport.park();
}
FairSync源码如下：
final void lock() {
acquire(1);
}
// 尝试获取状态
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// cas设置state
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
// 可重入
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
lock操作
lock操作也就是执行acquire(1)，首先尝试获取锁成功直接返回，失败初始化一个Node放入阻塞队列，然后阻塞自己。
public final void acquire(int arg) {
// 尝试获取锁成功直接返回
// 失败创建Node放入同步队列
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
addWaiter(Node.EXCLUSIVE)就是将初始化的Node CAS放到tail处，不再赘述，重点看下acquireQueued逻辑。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
// 如果pre是头节点，再次尝试获取锁
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 否则需要变更waitStatus，然后阻塞自己，等待占用state的线程来唤醒自己
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
Node的waitStatus有以下几种类型，其中要注意SIGNAL时表示当前线程需要唤醒下一个阻塞的节点线程：
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
unlock操作
unlock操作就是lock的逆操作，相对来说比较简单，AQS的realase源码如下：
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
tryRelease(arg)就是当前state重置为0，然后判断同步队列头结点，如果非空并且waitStatus!=0则进行唤醒下一个节点操作，源码如下：
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* 找到下一个可以待唤醒的节点
* waitStatus>0表示当前线程已经处于唤醒状态了，比如异常或者等待超时
*/
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);
}
最后执行unpark之后，同步队列中第一个阻塞的线程就被唤醒，可以尝试更新状态了。关于LockSupport.unpark这块具体可以参考为什么说LockSupport是Java并发的基石？
推荐阅读
