1. 为什么AQS是Java面试的必考知识点？
在Java多线程编程领域，AbstractQueuedSynchronizer（AQS）堪称并发编程的基石级框架。我面试过上百名Java开发者，发现能真正讲清楚AQS工作原理的候选人不足20%。这个数字很能说明问题——AQS既是技术深度的试金石，也是区分普通开发者和高级开发者的关键指标。
AQS的重要性体现在三个方面：首先，它是Java并发包（JUC）的核心实现基础，像ReentrantLock、CountDownLatch这些常用工具类都是基于AQS构建的；其次，理解AQS能帮助我们掌握锁、同步器等并发工具的设计思想；最后，AQS的实现涉及大量精妙的设计模式和多线程编程技巧，是检验开发者内功的绝佳案例。
2. AQS同步机制的设计哲学
2.1 同步状态的管理艺术
AQS的核心是一个volatile修饰的int类型状态变量（state），这个看似简单的设计却蕴含着精妙的并发控制思想。state的不同取值代表不同的同步状态：
- 0表示资源未被锁定
- 1表示资源被独占锁定
-
1通常表示重入次数（如ReentrantLock）
关键点：state使用volatile保证可见性，配合CAS操作实现无锁化的状态变更，这是AQS高性能的关键。
java复制// AQS中状态管理的核心代码片段
private volatile int state;
protected final int getState() {
return state;
}
protected final void setState(int newState) {
state = newState;
}
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
2.2 CLH队列的变体实现
AQS使用CLH锁的变体来实现线程排队。这个FIFO队列不是传统的链表结构，而是通过两个原子引用（head和tail）和节点内部的waitStatus状态来实现的。每个等待线程都被包装成一个Node节点：
java复制static final class Node {
volatile int waitStatus;
volatile Node prev;
volatile Node next;
volatile Thread thread;
Node nextWaiter;
}
waitStatus的几个关键值：
- CANCELLED(1)：线程已取消
- SIGNAL(-1)：后继节点需要唤醒
- CONDITION(-2)：节点在条件队列中
- PROPAGATE(-3)：共享模式下传播唤醒
3. 独占式同步：以ReentrantLock为例
3.1 加锁流程深度解析
当线程调用lock()方法时，背后的故事是这样的：
- 尝试通过CAS将state从0改为1（快速路径）
- 如果失败，调用acquire(1)进入排队流程
- acquire方法会先尝试tryAcquire（子类实现）
- 如果还不成功，将线程包装成Node加入队列
- 最终可能进入LockSupport.park()挂起
java复制// ReentrantLock中NonfairSync的实现
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
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;
}
3.2 解锁流程与唤醒机制
unlock()操作同样精妙：
- 尝试释放锁（tryRelease）
- 如果完全释放（state==0），唤醒后继节点
- 后继节点被唤醒后会重新尝试获取锁
常见坑点：很多开发者不知道unlock()必须放在finally块中，否则可能导致死锁。
4. 共享式同步：CountDownLatch案例分析
4.1 共享模式的工作原理
共享模式与独占模式的关键区别在于：
- 多个线程可以同时获取锁
- 状态值可以大于1（表示可用许可数）
- 唤醒操作会传播（一个线程被唤醒后会继续唤醒其后继）
CountDownLatch的await()和countDown()就是典型的共享模式应用：
java复制// CountDownLatch.Sync的实现
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;
}
}
4.2 应用场景对比
| 特性 | 独占式 | 共享式 |
|---|---|---|
| 适用场景 | 互斥访问资源 | 限制并发数/协同多个线程 |
| 典型实现 | ReentrantLock | CountDownLatch |
| 状态值含义 | 通常0/1表示锁状态 | 可以>1表示可用许可数 |
| 唤醒策略 | 只唤醒下一个节点 | 唤醒所有等待节点（传播唤醒） |
| 重入支持 | 支持（如ReentrantLock） | 通常不支持 |
5. 面试中的高频问题与解答技巧
5.1 必问题目清单
-
AQS的核心数据结构是什么？
- 答：volatile int state + CLH队列变体
-
为什么AQS要采用CLH队列？
- 答：CLH锁的优点是不需要频繁的CAS更新队首指针，只需要关注前驱节点的状态
-
独占式和共享式的区别是什么？
- 答：从状态管理、唤醒策略、应用场景三个维度回答（参考上表）
-
如何基于AQS实现一个自定义锁？
- 答：继承AQS并实现tryAcquire/tryRelease（共享模式则实现tryAcquireShared等）
5.2 回答技巧
- 结合源码：能引用关键代码片段的回答更有说服力
- 画图辅助：描述队列变化时最好画出节点状态变化图
- 联系实际：把原理和ReentrantLock等具体实现联系起来
- 对比分析：比较不同同步方式的优缺点
6. 实战中的经验与坑点
6.1 性能调优要点
- 减少锁竞争：通过减小锁粒度或使用读写锁优化
- 避免虚假唤醒：条件等待要放在while循环中检查
- 注意锁顺序：避免死锁，按固定顺序获取多个锁
java复制// 错误的锁顺序可能导致死锁
public void transfer(Account from, Account to, int amount) {
synchronized(from) { // 先获取from的锁
synchronized(to) { // 再获取to的锁
// 转账操作
}
}
}
// 正确的做法是定义全局的锁获取顺序
private static final Object tieLock = new Object();
public void transfer(Account from, Account to, int amount) {
int fromHash = System.identityHashCode(from);
int toHash = System.identityHashCode(to);
if (fromHash < toHash) {
synchronized(from) {
synchronized(to) {
// 转账操作
}
}
} else if (fromHash > toHash) {
synchronized(to) {
synchronized(from) {
// 转账操作
}
}
} else {
synchronized(tieLock) {
synchronized(from) {
synchronized(to) {
// 转账操作
}
}
}
}
}
6.2 调试技巧
- 使用jstack查看线程状态和锁持有情况
- 通过-XX:+PrintConcurrentLocks参数打印锁信息
- 使用VisualVM或JProfiler分析锁竞争情况
我在实际项目中遇到过这样一个案例：一个使用ReentrantLock的缓存系统在高并发时出现性能下降。通过线程dump发现大量线程处于WAITING状态，最终发现是因为锁粒度过大。将一个大锁拆分为多个小锁后，吞吐量提升了3倍。
7. AQS的进阶理解
7.1 条件变量的实现
ConditionObject是AQS的内部类，实现了条件队列功能。它与同步队列的关系值得深入研究：
- 当调用await()时，线程会从同步队列转移到条件队列
- signal()操作会将节点从条件队列移回同步队列
- 每个ConditionObject维护一个独立的条件队列
java复制// 典型的生产者-消费者模式实现
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
7.2 公平与非公平的实现差异
公平与非公平锁的性能差异主要来自线程切换的开销：
- 公平锁：严格按照队列顺序获取锁，减少饥饿但吞吐量低
- 非公平锁：允许插队，吞吐量高但可能导致饥饿
java复制// 非公平锁的tryAcquire实现
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) { // 直接尝试获取，不检查队列
setExclusiveOwnerThread(current);
return true;
}
}
// ...重入逻辑
}
// 公平锁的tryAcquire实现
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;
}
}
// ...重入逻辑
}
在实际项目中，除非有严格的公平性要求，否则通常建议使用非公平锁以获得更好的性能。根据我的测试，在高度竞争的场景下，非公平锁的吞吐量可以比公平锁高出1-2个数量级。