在Java并发编程中，AbstractQueuedSynchronizer（简称AQS）是一个非常重要的抽象类，它为构建锁和同步器提供了一个强大且灵活的框架。AQS的设计理念和实现机制对于理解Java并发工具的工作原理至关重要。本文将深入探讨AQS的核心概念、数据结构、工作原理以及如何利用它来构建自定义的同步器。
1 AQS概述
AQS是AbstractQueuedSynchronizer的简称，从字面上可以理解为：
- 抽象：AQS是一个抽象类，只实现了一些主要的逻辑，具体的方法由子类实现。
- 队列：AQS使用先进先出（FIFO）的队列来存储数据。
- 同步：AQS实现了同步的功能，能够协调多个线程对共享资源的访问。
AQS的主要用途是作为一个框架，用于构建各种锁和同步器。许多Java并发工具，如ReentrantLock、Semaphore、ReentrantReadWriteLock、SynchronousQueue、FutureTask等，都是基于AQS实现的。通过AQS，开发者可以轻松地定制自己的同步器，只需实现几个关键的protected方法即可。
2 AQS的数据结构
AQS的核心数据结构包括一个volatile的state变量和一个先进先出（FIFO）的双端队列。
-
state变量：用于表示同步状态，其值可以通过getState()、setState()和compareAndSetState()方法进行操作。这些操作都是原子操作，确保了线程安全性。 -
双端队列：AQS内部维护了一个双端队列，队列中的每个节点代表一个等待获取资源的线程。队列的头节点和尾节点分别由
head和tail引用标识。但它并不直接储存线程，而是储存拥有线程的Node节点。
3 Node节点
AQS中的节点（Node）用于表示等待队列中的线程。每个节点包含以下关键属性：
-
waitStatus：表示节点的状态，可能的值包括：CANCELLED：节点对应的线程已被取消。SIGNAL：后继节点需要被唤醒。CONDITION：节点在等待某个条件。PROPAGATE：共享模式下，资源释放后需要无条件传播唤醒后继节点。0：默认状态，表示节点正常等待。
-
prev和next：分别指向前驱节点和后继节点，用于实现双向链表。 -
thread：节点对应的线程。 -
nextWaiter：用于在Condition队列中指向下一个等待条件的节点。
Node 的结构：
static final class Node {
// 标记一个结点（对应的线程）在共享模式下等待
static final Node SHARED = new Node();
// 标记一个结点（对应的线程）在独占模式下等待
static final Node EXCLUSIVE = null;
// waitStatus的值，表示该结点（对应的线程）已被取消
static final int CANCELLED = 1;
// waitStatus的值，表示后继结点（对应的线程）需要被唤醒
static final int SIGNAL = -1;
// waitStatus的值，表示该结点（对应的线程）在等待某一条件
static final int CONDITION = -2;
/*waitStatus的值，表示有资源可用，新head结点需要继续唤醒后继结点（共享模式下，多线程并发释放资源，而head唤醒其后继结点后，需要把多出来的资源留给后面的结点；设置新的head结点时，会继续唤醒其后继结点）*/
static final int PROPAGATE = -3;
// 等待状态，取值范围，-3，-2，-1，0，1
volatile int waitStatus;
volatile Node prev; // 前驱结点
volatile Node next; // 后继结点
volatile Thread thread; // 结点对应的线程
Node nextWaiter; // 等待队列里下一个等待条件的结点
// 判断共享模式的方法
final boolean isShared() {
return nextWaiter == SHARED;
}
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
// 其它方法忽略，可以参考具体的源码
}
// AQS里面的addWaiter私有方法
private Node addWaiter(Node mode) {
// 使用了Node的这个构造函数
Node node = new Node(Thread.currentThread(), mode);
// 其它代码省略
}
通过 Node 我们可以实现两种队列：
- 一是通过
prev和next实现CLH（Craig, Landin, and Hagersten）队列（线程同步队列、双向队列） - 二是通过
nextWaiter实现Condition上的等待线程队列（单向队列），这个Condition主要用在ReentrantLock类中。
4 资源共享模式
AQS支持两种资源共享模式：
-
独占模式（Exclusive）：资源是独占的，一次只能有一个线程获取。例如，
ReentrantLock就是基于独占模式实现的。 -
共享模式（Share）：资源可以被多个线程同时获取，具体的资源个数可以通过参数指定。例如，
Semaphore和CountDownLatch就是基于共享模式实现的。
5 AQS的源码解析
AQS的设计基于模板方法模式，其中一些关键方法需要子类实现。这些方法包括：
isHeldExclusively()：判断当前线程是否正在独占资源。tryAcquire(int)：尝试以独占模式获取资源。tryRelease(int)：尝试以独占模式释放资源。tryAcquireShared(int)：尝试以共享模式获取资源。tryReleaseShared(int)：尝试以共享模式释放资源。
AQS提供了获取和释放资源的主要逻辑，子类只需实现上述方法即可。
5.1 获取资源
获取资源的入口是acquire(int arg)方法。该方法首先尝试通过tryAcquire(arg)获取资源，如果失败，则通过 addWaiter(Node.EXCLUSIVE) 方法将当前线程封装成一个节点并插入到等待队列的尾部。随后，线程会在队列中自旋等待，直到获取到资源或被中断。
acquire(int arg)方法：
public final void accquire(int arg) {
// tryAcquire 再次尝试获取锁资源，如果尝试成功，返回true，尝试失败返回false
if (!tryAcquire(arg) &&
// 走到这，代表获取锁资源失败，需要将当前线程封装成一个Node，追加到AQS的队列中
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
// 线程中断
selfInterrupt();
}
acquireQueued(final Node node, int arg)方法
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
// interrupted用于记录线程是否被中断过
boolean interrupted = false;
for (;;) { // 自旋操作
// 获取当前节点的前驱节点
final Node p = node.predecessor();
// 如果前驱节点是head节点，并且尝试获取同步状态成功
if (p == head && tryAcquire(arg)) {
// 设置当前节点为head节点
setHead(node);
// 前驱节点的next引用设为null，帮助垃圾回收器回收该节点
p.next = null;
// 获取同步状态成功，将failed设为false
failed = false;
// 返回线程是否被中断过
return interrupted;
}
// 如果应该让当前线程阻塞并且线程在阻塞时被中断，则将interrupted设为true
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
interrupted = true;
}
} finally {
// 如果获取同步状态失败，取消尝试获取同步状态
if (failed)
cancelAcquire(node);
}
}
addWaiter(Node mode)方法
private Node addWaiter(Node mode) {
//创建 Node 类，并且设置 thread 为当前线程，设置为排它锁
Node node = new Node(Thread.currentThread(), mode);
// 获取 AQS 中队列的尾部节点
Node pred = tail;
// 如果 tail == null，说明是空队列，
// 不为 null，说明现在队列中有数据，
if (pred != null) {
// 将当前节点的 prev 指向刚才的尾部节点，那么当前节点应该设置为尾部节点
node.prev = pred;
// CAS 将 tail 节点设置为当前节点
if (compareAndSetTail(pred, node)) {
// 将之前尾节点的 next 设置为当前节点
pred.next = node;
// 返回当前节点
return node;
}
}
enq(node);
return node;
}
// 自旋CAS插入等待队列
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
acquire流程：
获取资源的方法除了 acquire 外，还有以下三个：
acquireInterruptibly：申请可中断的资源（独占模式）acquireShared：申请共享模式的资源acquireSharedInterruptibly：申请可中断的资源（共享模式）
可中断的意思是，在线程中断时可能会抛出InterruptedException。
5.2 释放资源
释放资源的入口是release(int arg)方法。该方法首先尝试通过tryRelease(arg)释放资源，如果成功，则唤醒等待队列中的后继节点。
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
private void unparkSuccessor(Node node) {
// 如果状态是负数，尝试把它设置为0
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 得到头结点的后继结点head.next
Node s = node.next;
// 如果这个后继结点为空或者状态大于0
// 通过前面的定义我们知道，大于0只有一种可能，就是这个结点已被取消（只有 Node.CANCELLED(=1) 这一种状态大于0）
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 自定义同步器
6.1 代码示例
通过AQS，开发者可以轻松地构建自定义的同步器。例如，下面是一个简单的互斥锁（Mutex）实现：
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
public class Mutex {
private static class Sync extends AbstractQueuedSynchronizer {
@Override
protected boolean tryAcquire(int arg) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
@Override
protected boolean tryRelease(int arg) {
if (getState() == 0) {
throw new IllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
@Override
protected boolean isHeldExclusively() {
return getState() == 1;
}
}
private final Sync sync = new Sync();
public void lock() {
sync.acquire(1);
}
public void unlock() {
sync.release(1);
}
public boolean isLocked() {
return sync.isHeldExclusively();
}
}
在这个例子中，Mutex类通过继承AQS实现了独占锁的功能。tryAcquire方法尝试获取锁，tryRelease方法尝试释放锁，而isHeldExclusively方法用于判断锁是否被当前线程持有。
6.2 示例测试类
为了测试我们自定义的Mutex同步器，我们可以编写一个简单的测试类，验证其锁定和解锁功能是否正常工作。以下是一个示例测试类：
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MutexTest {
public static void main(String[] args) {
final Mutex mutex = new Mutex();
final int threadCount = 10;
final CountDownLatch startSignal = new CountDownLatch(1);
final CountDownLatch doneSignal = new CountDownLatch(threadCount);
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
for (int i = 0; i < threadCount; i++) {
executor.execute(new Worker(mutex, startSignal, doneSignal));
}
// 启动所有线程
startSignal.countDown();
// 等待所有线程完成
try {
doneSignal.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 关闭线程池
executor.shutdown();
// 检查锁状态
if (mutex.isLocked()) {
System.out.println("Test failed: Mutex is still locked.");
} else {
System.out.println("Test passed: Mutex is unlocked.");
}
}
static class Worker implements Runnable {
private final Mutex mutex;
private final CountDownLatch startSignal;
private final CountDownLatch doneSignal;
Worker(Mutex mutex, CountDownLatch startSignal, CountDownLatch doneSignal) {
this.mutex = mutex;
this.startSignal = startSignal;
this.doneSignal = doneSignal;
}
@Override
public void run() {
try {
startSignal.await();
mutex.lock();
System.out.println(Thread.currentThread().getName() + " acquired the lock.");
// 模拟一些工作
Thread.sleep(100);
mutex.unlock();
System.out.println(Thread.currentThread().getName() + " released the lock.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
doneSignal.countDown();
}
}
}
}
6.3 测试类说明
-
线程池和信号量：
- 使用
ExecutorService创建一个固定大小的线程池，线程池的大小为10。 - 使用
CountDownLatch来控制线程的启动和结束。startSignal用于同步所有线程的启动，doneSignal用于等待所有线程完成。
- 使用
-
Worker线程：
Worker类实现了Runnable接口，每个Worker线程在启动后会尝试获取Mutex锁，然后模拟一些工作（通过Thread.sleep(100)），最后释放锁。
-
测试逻辑：
- 启动所有线程后，主线程等待所有
Worker线程完成。 - 所有线程完成后，检查
Mutex锁的状态。如果锁仍然被持有，则测试失败；否则，测试通过。
- 启动所有线程后，主线程等待所有
6.4 运行结果
运行上述测试类后，如果Mutex锁的实现是正确的，所有线程应该能够依次获取和释放锁，最终Mutex锁的状态应该是解锁的。输出结果类似于：
pool-1-thread-1 acquired the lock.
pool-1-thread-1 released the lock.
pool-1-thread-2 acquired the lock.
pool-1-thread-2 released the lock.
...
Test passed: Mutex is unlocked.
通过这个测试类，我们可以验证Mutex锁的正确性和线程安全性。
7 总结
AQS是Java并发编程中的一个核心框架，它为构建锁和同步器提供了一个强大且灵活的基础。通过AQS，开发者可以轻松地实现各种复杂的同步逻辑，而无需从头开始编写复杂的线程同步代码。理解AQS的工作原理和设计思想，对于掌握Java并发编程至关重要。
通过本文的介绍，希望读者能够对AQS有一个全面的了解，并能够在实际项目中灵活运用AQS来解决并发问题。
8 思维导图
扫一扫
505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
