深入浅出AQS：Java并发编程的核心基石

今天我们来聊聊Java并发编程中那个既神秘又重要的核心组件——AQS（AbstractQueuedSynchronizer）。它就像是并发世界的"隐形守护者"，虽然你看不见它，但ReentrantLock、CountDownLatch、Semaphore等并发工具都离不开它的支持。

一、AQS是什么？为什么重要？

AQS，全称AbstractQueuedSynchronizer（抽象队列同步器），是Java并发包java.util.concurrent.locks的核心框架。它提供了一个基于FIFO等待队列的同步器框架，通过一个int类型的状态变量state来表示同步状态。

简单来说，**AQS就是Java并发工具类的"骨架"**。当你使用ReentrantLock时，背后就是AQS在默默工作。

二、AQS的核心设计思想

2.1 状态管理：state变量

AQS使用一个volatile int state变量来表示同步状态并通过CAS更新状态：

state的不同含义：

• 在ReentrantLock中：state=0表示锁空闲，state>0表示锁被持有，可重入

• 在Semaphore中：state表示可用许可数
• state = 0：没有可用许可，新线程需要等待
• state > 0：有可用许可，线程可以获取
• 最大值限制：防止整数溢出
• 在CountDownLatch中：state表示计数器值

State变量的设计哲学

1. 状态集中化

一个state变量，多种语义：通过将多个状态编码到一个int中，减少了多个变量间的同步问题。

1. 无锁化设计

CAS代替锁：通过CAS操作更新state，避免了使用重量级锁，提高了并发性能。

1. 可扩展性

模板方法模式：AQS定义了state的管理框架，具体语义由子类实现。

1. 空间效率

位运算优化：使用位运算将多个状态压缩到一个变量中，如读写锁的高低16位分离。

2.2 CLH队列：线程等待的"候车室"

AQS内部维护了一个FIFO双向队列（CLH锁的变体），当线程获取同步状态失败时，会被包装成Node节点加入队列：

staticfinalclassNode{
// 节点模式
staticfinal Node SHARED = new Node();  // 共享模式
staticfinal Node EXCLUSIVE = null;     // 独占模式

// 等待状态
staticfinalint CANCELLED = 1;   // 取消
staticfinalint SIGNAL = -1;     // 需要唤醒后继节点
staticfinalint CONDITION = -2;  // 在条件队列中等待
staticfinalint PROPAGATE = -3;  // 共享模式下传播

volatileint waitStatus;  // 等待状态
volatile Node prev;       // 前驱节点
volatile Node next;       // 后继节点
volatile Thread thread;   // 节点关联的线程
    Node nextWaiter;          // 下一个等待者
}

队列的状态转换全流程

三、AQS的两种模式

3.1 独占模式（Exclusive）

同一时刻只有一个线程能获取同步状态，如ReentrantLock：

// 独占模式获取锁
publicfinalvoidacquire(int arg){
if (!tryAcquire(arg) &&  // 尝试获取
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  // 获取失败，加入队列
        selfInterrupt();  // 恢复中断状态
}

独占模式获取流程：

3.2 共享模式（Shared）

多个线程可以同时获取同步状态，如Semaphore、CountDownLatch：

// 共享模式获取
publicfinalvoidacquireShared(int arg){
if (tryAcquireShared(arg) < 0)  // 尝试获取
        doAcquireShared(arg);  // 获取失败，加入队列等待
}

四、源码深度解析：以ReentrantLock为例

4.1 ReentrantLock的公平锁实现

// 公平锁的tryAcquire实现
protectedfinalbooleantryAcquire(int acquires){
final Thread current = Thread.currentThread();
int c = getState();  // 获取当前状态

if (c == 0) {  // 锁未被占用
if (!hasQueuedPredecessors() &&  // 公平性：检查是否有前驱节点
            compareAndSetState(0, acquires)) {  // CAS设置状态
            setExclusiveOwnerThread(current);  // 设置当前线程为持有者
returntrue;
        }
    }
elseif (current == getExclusiveOwnerThread()) {  // 重入
int nextc = c + acquires;
if (nextc < 0)
thrownew Error("Maximum lock count exceeded");
        setState(nextc);
returntrue;
    }
returnfalse;
}

4.2 acquireQueued：队列中的等待与唤醒

finalbooleanacquireQueued(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;  // help GC
                failed = false;
return interrupted;
            }

// 判断是否需要park，然后park当前线程
if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
if (failed)
            cancelAcquire(node);  // 取消获取
    }
}

4.3 解锁过程：release

publicfinalbooleanrelease(int arg){
if (tryRelease(arg)) {  // 尝试释放
        Node h = head;  // 获取头节点
if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);  // 唤醒后继节点
returntrue;
    }
returnfalse;
}

// 唤醒后继节点
privatevoidunparkSuccessor(Node node){
int ws = node.waitStatus;
if (ws < 0)
        compareAndSetWaitStatus(node, ws, 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);  // 唤醒线程
}

六、AQS的条件变量：ConditionObject

AQS还提供了条件变量的支持，用于实现等待/通知机制：

publicclassConditionObjectimplementsCondition{
// 条件队列（单向链表）
privatetransient Node firstWaiter;
privatetransient Node lastWaiter;

// 等待方法
publicfinalvoidawait()throws InterruptedException {
if (Thread.interrupted())
thrownew 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);
    }

// 通知方法
publicfinalvoidsignal(){
if (!isHeldExclusively())
thrownew IllegalMonitorStateException();

        Node first = firstWaiter;
if (first != null)
            doSignal(first);  // 唤醒条件队列中的第一个节点
    }
}

七、AQS的最佳实践与注意事项

7.1 性能优化要点

1. 减少CAS操作：在tryAcquire中先进行状态检查，再考虑CAS
2. 避免过度阻塞：适当使用tryAcquire和超时机制
3. 合理设置state范围：根据业务需求设计state的语义

7.2 常见陷阱

// 错误示例：没有正确处理中断
publicvoidwrongLockMethod(){
    lock.lock();
try {
// 业务逻辑
        Thread.sleep(1000);  // 可能被中断，但没有处理
    } finally {
        lock.unlock();
    }
}

// 正确示例：正确处理中断
publicvoidcorrectLockMethod()throws InterruptedException {
    lock.lockInterruptibly();  // 可中断的获取锁
try {
// 业务逻辑
        Thread.sleep(1000);
    } finally {
        lock.unlock();
    }
}

7.3 调试技巧

1. 查看AQS内部状态：

// 通过反射获取AQS内部状态
Field syncField = ReentrantLock.class.getDeclaredField("sync");
syncField.setAccessible(true);
Object sync = syncField.get(lock);

Field stateField = sync.getClass().getSuperclass().getDeclaredField("state");
stateField.setAccessible(true);
int state = (int) stateField.get(sync);
System.out.println("AQS state: " + state);

1. 使用线程转储分析：

# 生成线程转储
jstack <pid> > thread_dump.txt

# 查找AQS相关的等待线程
grep -A 5 "AbstractQueuedSynchronizer" thread_dump.txt

八、总结

AQS是Java并发编程的基石，它通过精妙的设计解决了同步问题：

1. 状态管理：使用volatile state + CAS操作保证原子性
2. 队列管理：CLH变体队列实现公平的线程等待
3. 模板方法：提供可扩展的框架，子类只需实现关键方法
4. 双模式：支持独占和共享两种同步模式

理解AQS不仅有助于我们更好地使用Java并发工具，还能让我们在遇到复杂的并发问题时，有能力自己设计合适的同步器。