引言
AbstractQueuedSynchronizer（简称 AQS）是 Java 并发包 java.util.concurrent 中的核心类，用于构建锁和其他同步组件。它是 Java 三大并发工具类（CountDownLatch、CyclicBarrier、Semaphore）的基础，同时也是 ReentrantLock 和 BlockingQueue 等类的实现基石。AQS 的重要性不言而喻，本文将通过源码解析，深入探讨 AQS 的内部机制。
一、AQS 的核心组件
1. 同步状态（state）
AQS 使用一个 volatile int state 来表示同步状态。state 的具体含义由子类定义，例如：
-
在
ReentrantLock中，state表示锁的重入次数。 -
在
Semaphore中，state表示剩余的许可证数量。
private volatile int state;AQS 提供了以下方法来操作 state：
-
getState()：获取当前状态值。 -
setState(int newState)：直接设置状态值。 -
compareAndSetState(int expect, int update)：通过 CAS 原子操作更新状态。
2. 等待队列
AQS 使用一个双向链表（CLH 队列）来管理等待线程。队列的头节点（head）是一个虚拟节点，不包含实际线程，尾节点（tail）始终指向队列的最后一个节点。
private transient volatile Node head;
private transient volatile Node tail;二、内部类 Node（等待队列的实现）
Node 是 AQS 的内部类，用于表示队列中的节点。每个节点封装了一个线程，节点的状态（waitStatus）有以下几种：
-
CANCELLED (1)：线程取消等待。 -
SIGNAL (-1)：当前节点的后继节点需要被唤醒。 -
CONDITION (-2)：节点在条件队列中。 -
PROPAGATE (-3)：共享模式下需要传播。 -
0：初始状态。
static final class Node {
static final int CANCELLED = 1;
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
volatile int waitStatus;
volatile Node prev;
volatile Node next;
volatile Thread thread;
Node nextWaiter;
}三、获取锁的源码解析
1. 独占模式（acquire）
acquire 方法是独占模式下获取锁的核心方法。它尝试获取锁，如果失败则将线程加入等待队列并阻塞。
public final void acquire(int arg) {
if (!tryAcquire(arg) && // 尝试获取锁
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 如果失败，加入队列并阻塞
selfInterrupt();
}-
tryAcquire：由子类实现，尝试获取锁。 -
addWaiter：将线程封装成一个节点并加入队列。 -
acquireQueued：尝试从队列中获取锁，如果失败则阻塞线程。
addWaiter 方法
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode); // 创建新节点
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) { // CAS 设置尾节点
pred.next = node;
return node;
}
}
enq(node); // 如果尾节点为空，调用 enq 方法
return node;
}enq 方法
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;
}
}
}
}acquireQueued 方法
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; // 帮助 GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) && // 如果需要阻塞
parkAndCheckInterrupt()) // 阻塞线程
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node); // 如果失败，取消节点
}
}2. 共享模式（acquireShared）
acquireShared 方法是共享模式下获取锁的核心方法。它允许多个线程同时获取锁。
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0) // 尝试获取共享锁
doAcquireShared(arg); // 如果失败，加入队列并阻塞
}-
tryAcquireShared：由子类实现，尝试获取共享锁。 -
doAcquireShared：如果获取失败，将线程加入队列并阻塞。
doAcquireShared 方法
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; // 帮助 GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) && // 如果需要阻塞
parkAndCheckInterrupt()) // 阻塞线程
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node); // 如果失败，取消节点
}
}四、释放锁的源码解析
1. 独占模式（release）
release 方法是独占模式下释放锁的核心方法。它尝试释放锁，并唤醒等待队列中的后继节点。
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：由子类实现，尝试释放锁。 -
unparkSuccessor：唤醒等待队列中的后继节点。
unparkSuccessor 方法
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0); // 如果节点状态为 SIGNAL，重置为 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); // 唤醒后继节点
}2. 共享模式（releaseShared）
releaseShared 方法是共享模式下释放锁的核心方法。它尝试释放共享锁，并唤醒等待队列中的后继节点。
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) { // 尝试释放共享锁
doReleaseShared(); // 唤醒后继节点
return true;
}
return false;
}-
tryReleaseShared：由子类实现，尝试释放共享锁。 -
doReleaseShared：唤醒等待队列中的后继节点。
doReleaseShared 方法
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) { // 如果头节点状态为 SIGNAL
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) // 重置状态为 0
continue; // 重试
unparkSuccessor(h); // 唤醒后继节点
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) // 如果状态为 0，设置为 PROPAGATE
continue; // 重试
}
if (h == head) // 如果头节点未变，退出循环
break;
}
}五、条件队列的源码解析
ConditionObject 是 AQS 的内部类，实现了 Condition 接口。它允许线程在某个条件满足时被唤醒，否则进入等待状态。
public class ConditionObject implements Condition {
private transient Node firstWaiter;
private transient Node lastWaiter;
public 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;
if (node.nextWaiter != null)
unlinkCancelledWaiters(); // 清理条件队列
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode); // 处理中断
}
public void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignal(first); // 唤醒条件队列中的第一个节点
}
}-
await：将线程加入条件队列，释放锁，并等待被唤醒。 -
signal：唤醒条件队列中的一个线程。
六、总结
AQS 是 Java 并发编程的核心框架，通过同步状态和队列机制，实现了高效的线程同步功能。理解 AQS 的源码和原理，对于掌握 Java 并发编程至关重要。希望本文能够帮助读者深入理解 AQS 的内部机制，为学习其他并发工具类（如 ReentrantLock、Semaphore 等）打下坚实的基础。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
