AbstractQueuedSynchronizer 的示例分析

# AbstractQueuedSynchronizer 的示例分析

## 目录
1. [引言](#引言)  
2. [AQS核心设计原理](#AQS核心设计原理)  
   2.1 [同步状态管理](#同步状态管理)  
   2.2 [CLH队列实现](#CLH队列实现)  
   2.3 [模板方法模式](#模板方法模式)  
3. [ReentrantLock中的AQS实战](#ReentrantLock中的AQS实战)  
   3.1 [公平锁实现](#公平锁实现)  
   3.2 [非公平锁差异](#非公平锁差异)  
4. [CountDownLatch的AQS应用](#CountDownLatch的AQS应用)  
5. [自定义同步器开发](#自定义同步器开发)  
6. [性能优化关键点](#性能优化关键点)  
7. [常见问题排查](#常见问题排查)  
8. [总结](#总结)  

## 引言
AbstractQueuedSynchronizer（简称AQS）是Java并发包的核心基础组件，自JDK1.5引入以来支撑了包括ReentrantLock、Semaphore等在内的多种同步工具实现。本文将通过深度源码分析结合典型示例，揭示其设计精髓与实践应用。

---

## AQS核心设计原理

### 同步状态管理
```java
// AQS内部状态维护
private volatile int state;

protected final int getState() {
    return state;
}

protected final void setState(int newState) {
    state = newState;
}

// CAS原子操作
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

状态变量state的不同语义： - 互斥锁：0表示未锁定，1表示锁定 - 读写锁：高16位记录读锁，低16位记录写锁 - 信号量：表示可用许可数

CLH队列实现

// 节点结构（简化版）
static final class Node {
    volatile int waitStatus;
    volatile Node prev;
    volatile Node next;
    volatile Thread thread;
    Node nextWaiter;
}

队列特性： 1. 双向FIFO队列 2. 通过自旋+CAS保证线程安全 3. 唤醒机制：前驱节点负责唤醒后继

模板方法模式

需要子类实现的关键方法：

protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); }
protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); }
protected int tryAcquireShared(int arg) { throw new UnsupportedOperationException(); }
protected boolean tryReleaseShared(int arg) { throw new UnsupportedOperationException(); }

ReentrantLock中的AQS实战

公平锁实现

// FairSync实现
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        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;
}

关键逻辑： 1. hasQueuedPredecessors()检查队列中有无更早线程 2. 可重入计数通过state累加实现

非公平锁差异

// NonfairSync实现
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {  // 直接尝试获取
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // ...可重入逻辑与公平锁相同
}

性能对比（JMH测试）：

CountDownLatch的AQS应用

共享模式典型实现：

protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

protected boolean tryReleaseShared(int releases) {
    for (;;) {
        int c = getState();
        if (c == 0) return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

使用场景： 1. 多线程任务等待 2. 系统启动屏障

自定义同步器开发

实现简单的二元闭锁：

class BooleanLatch extends AbstractQueuedSynchronizer {
    protected int tryAcquireShared(int ignore) {
        return getState() == 1 ? 1 : -1;
    }
    
    protected boolean tryReleaseShared(int ignore) {
        setState(1);
        return true;
    }
    
    public void signal() {
        releaseShared(1);
    }
}

性能优化关键点

1. 自旋策略：在入队前尝试2-3次快速获取
2. 队列缩减：取消节点时及时清理无效引用
3. 线程中断：正确处理Thread.interrupted()

常见问题排查

1. 死锁场景：

// 错误示例
lockA.lock();
try {
    lockB.lock();  // 另一线程持有lockB请求lockA
    ...
} finally {
    lockA.unlock();
}

诊断工具： - jstack查看线程阻塞链 - ThreadMXBean.findDeadlockedThreads()

1. 状态异常：

if (lock.tryLock()) {
    try {
        // 业务逻辑
    } finally {
        lock.unlock();  // 未获取锁时调用会抛出IllegalMonitorStateException
    }
}

总结

AQS通过精妙的设计实现了同步器的三个核心要素： 1. 原子状态管理（volatile + CAS） 2. 线程阻塞/唤醒（LockSupport） 3. 队列维护（CLH变体）

掌握AQS原理对于： - 理解Java并发工具实现 - 开发高性能自定义同步组件 - 诊断复杂并发问题 具有不可替代的价值。 “`

（注：实际完整文章包含更多代码示例、性能数据图表和参考文献，此处为精简版结构展示）