定位:你知道AQS是CLH队列+state,面试也能说个大概。但面试官问"waitStatus每个值的含义""unparkSuccessor为什么要从tail往前找""手写一个ReentrantLock",你就卡住了。本节专治这个gap。
// AQS内部类 Node 的核心字段
static final class Node {
// ======== waitStatus 值(面试必背) ========
static final int CANCELLED = 1; // 线程被取消(超时/中断)
static final int SIGNAL = -1; // 后继节点需要被唤醒
static final int CONDITION = -2; // 在Condition队列中
static final int PROPAGATE = -3; // 共享模式传播唤醒
volatile int waitStatus;
volatile Node prev; // 前驱节点(CLH队列是双向链表)
volatile Node next; // 后继节点
volatile Thread thread; // 等待的线程
Node nextWaiter; // Condition队列的下一个节点 / 模式标记
// isShared():nextWaiter == SHARED 表示共享模式
}
waitStatus 状态转换图(面试画图题):
初始化:waitStatus = 0
独占模式获取:
0 ──[enq入队]──→ 前驱设为SIGNAL(-1) ──[shouldParkAfterFailedAcquire]──→ park
│
CANCELLED(1) ←──[超时/中断]──────────────────────────────────────────────┘
共享模式获取:
0 ──[入队]──→ SIGNAL(-1) ──[被唤醒]──→ PROPAGATE(-3)(传播唤醒后继)
Condition队列:
入队时设为CONDITION(-2),signal后移回CLH队列设为0
acquire(int arg) 流程(ReentrantLock.lock()的底层):
tryAcquire(arg) ──成功──→ 返回(获取到锁)
│
失败
│
▼
addWaiter(Node.EXCLUSIVE) ──→ 创建Node并入队CLH尾部
│
▼
acquireQueued(node, arg) ──→ 自旋/park等待
│
├── 前驱是head && tryAcquire成功 → 设为head,返回
│
└── shouldParkAfterFailedAcquire
│
├── 前驱ws == SIGNAL → 安全park → LockSupport.park(this)
│
├── 前驱ws > 0 (CANCELLED) → 跳过已取消节点
│
└── 前驱ws == 0 → CAS设为SIGNAL → 下一轮再park
release(int arg) 流程:
tryRelease(arg) ──失败──→ 返回false
│
成功
│
▼
head != null && head.waitStatus != 0 ?
│
是
│
▼
unparkSuccessor(head)
│
├── ws < 0 → CAS将ws设为0
│
├── s.next != null && s.waitStatus <= 0 → LockSupport.unpark(s.thread)
│
└── next为空或已取消 → 从tail往前遍历找到最近的未取消节点
面试重点:为什么要从tail往前遍历?
→ 因为enq()中是先设置node.prev = pred,再CAS设置tail,最后才设置pred.next = node
→ 如果从head往后遍历,可能漏掉刚入队但next还没设置的节点
→ 从tail往前遍历,prev指针是入队时就设置好的,保证不会遗漏
acquireShared(int arg):
tryAcquireShared(arg)
返回值 < 0 → 获取失败,入队等待
返回值 >= 0 → 获取成功
如果获取成功 && head.waitStatus是SIGNAL/PROPAGATE
→ doReleaseShared() 传播唤醒后继共享节点
releaseShared(int arg):
tryReleaseShared(arg) → true
│
▼
doReleaseShared():
循环从head开始:
ws == SIGNAL → CAS设为0 → unpark后继
ws == 0 → CAS设为PROPAGATE(确保后续获取能传播)
如果head没变 → 跳出循环;变了 → 继续
ConditionObject 维护一个单向链表(firstWaiter → lastWaiter)
await() 流程:
1. addConditionWaiter() → 创建新Node(ws=CONDITION),加入Condition队列尾部
2. fullyRelease(node) → 释放锁(调用release),唤醒CLH队列中的后继
3. while(!isOnSyncQueue(node)) → park等待
4. 被唤醒后 → acquireQueued() 重新获取锁
signal() 流程:
1. firstWaiter != null
2. transferForSignature(firstWaiter)
→ CAS将ws从CONDITION改为0
→ enq(node) 将节点从Condition队列移到CLH队列尾部
→ 如果前驱已取消或CAS设置SIGNAL失败 → LockSupport.unpark(node.thread)
3. firstWaiter = firstWaiter.nextWaiter
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
* 手写简化版 ReentrantLock —— 基于AQS模板方法
*
* 只实现核心功能:lock / unlock / tryLock / newCondition
* 不实现公平锁、中断、超时等高级特性
*/
public class SimpleReentrantLock implements Lock {
private final Sync sync;
public SimpleReentrantLock() {
this.sync = new Sync();
}
// ========== AQS核心实现 ==========
private static class Sync extends AbstractQueuedSynchronizer {
/**
* 尝试获取锁(独占模式)
*
* state含义:
* 0 → 未锁定
* >0 → 锁定,值=重入次数
*/
@Override
protected boolean tryAcquire(int arg) {
Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 无锁状态,CAS尝试获取(非公平)
if (compareAndSetState(0, arg)) {
setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
// 当前线程已持有锁 → 重入
int nextc = c + arg;
if (nextc < 0) {
throw new Error("Maximum lock count exceeded");
}
setState(nextc);
return true;
}
return false;
}
/**
* 尝试释放锁
*/
@Override
protected boolean tryRelease(int arg) {
int c = getState() - arg;
if (Thread.currentThread() != getExclusiveOwnerThread()) {
throw new IllegalMonitorStateException("非锁持有线程尝试释放");
}
boolean free = false;
if (c == 0) {
// 完全释放
free = true;
setExclusiveOwnerThread(null);
}
setState(c); // 注意:这里不需要CAS,因为只有持有锁的线程才能释放
return free;
}
@Override
protected boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
Condition newCondition() {
return new ConditionObject();
}
}
// ========== Lock接口实现 ==========
@Override
public void lock() {
sync.acquire(1);
}
@Override
public void unlock() {
sync.release(1);
}
@Override
public boolean tryLock() {
return sync.tryAcquire(1);
}
@Override
public Condition newCondition() {
return sync.newCondition();
}
// 以下方法简化实现,不在本节重点
@Override public void lockInterruptibly() throws InterruptedException {
throw new UnsupportedOperationException("简化版未实现");
}
@Override public boolean tryLock(long time, java.util.concurrent.TimeUnit unit)
throws InterruptedException {
throw new UnsupportedOperationException("简化版未实现");
}
}
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
/**
* 手写简化版 CountDownLatch —— 基于AQS共享模式
*
* state含义:剩余计数(每次countDown减1,减到0时唤醒所有等待线程)
*/
public class SimpleCountDownLatch {
private final Sync sync;
public SimpleCountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
sync = new Sync(count);
}
private static class Sync extends AbstractQueuedSynchronizer {
Sync(int count) {
setState(count);
}
/**
* 共享模式获取:state == 0 时返回正数(允许),否则返回-1(阻塞)
*
* 这里返回值含义:
* 负数 → 获取失败,需要入队等待
* 零 → 获取成功,但不传播
* 正数 → 获取成功,且传播唤醒后继
*/
@Override
protected int tryAcquireShared(int arg) {
return getState() == 0 ? 1 : -1;
}
/**
* 共享模式释放:将state减1,减到0返回true
*/
@Override
protected boolean tryReleaseShared(int arg) {
for (;;) {
int c = getState();
if (c == 0) return false; // 已经是0,不需要再减
int nextc = c - 1;
if (compareAndSetState(c, nextc)) {
return nextc == 0; // 减到0时返回true,触发doReleaseShared
}
}
}
}
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public void countDown() {
sync.releaseShared(1);
}
public long getCount() {
return sync.getState();
}
}
/**
* 测试手写的 SimpleReentrantLock 和 SimpleCountDownLatch
*/
public class AqsDemo {
public static void testReentrantLock() throws Exception {
SimpleReentrantLock lock = new SimpleReentrantLock();
int[] counter = {0};
// 测试重入性
lock.lock();
lock.lock(); // 重入
try {
counter[0]++;
System.out.println("重入成功,counter=" + counter[0]);
} finally {
lock.unlock();
lock.unlock(); // 需要解锁两次
}
// 测试多线程互斥
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
lock.lock();
try {
counter[0]++;
} finally {
lock.unlock();
}
}
};
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("最终 counter=" + counter[0]); // 期望2001(1 + 2000)
}
public static void testCountDownLatch() throws Exception {
SimpleCountDownLatch latch = new SimpleCountDownLatch(3);
for (int i = 0; i < 3; i++) {
final int idx = i;
new Thread(() -> {
try { Thread.sleep(1000 * (idx + 1)); } catch (Exception e) {}
System.out.println("线程 " + idx + " 完成,剩余=" + latch.getCount());
latch.countDown();
}).start();
}
System.out.println("主线程等待...");
latch.await();
System.out.println("所有线程完成");
}
public static void main(String[] args) throws Exception {
testReentrantLock();
System.out.println("---");
testCountDownLatch();
}
}
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
/**
* 通过反射观察AQS内部队列状态
* 验证CLH队列在竞争时的节点变化
*/
public class AqsQueueVisualizer {
public static void main(String[] args) throws Exception {
ReentrantLock lock = new ReentrantLock();
// 主线程持有锁
lock.lock();
// 启动3个等待线程
Thread[] waiters = new Thread[3];
for (int i = 0; i < 3; i++) {
final int idx = i;
waiters[i] = new Thread(() -> {
lock.lock();
try {
System.out.println("线程" + idx + "获得锁");
Thread.sleep(500);
} catch (Exception e) {
} finally {
lock.unlock();
}
}, "Waiter-" + i);
waiters[i].start();
Thread.sleep(100); // 确保依次入队
}
// 此时CLH队列:head → Waiter-0 → Waiter-1 → Waiter-2 → tail
// 使用jstack观察这些线程的状态(都是BLOCKED/LockSupport.park)
System.out.println("使用jstack " + ProcessHandle.current().pid() + " 观察队列");
Thread.sleep(10000);
lock.unlock(); // 唤醒第一个等待者
for (Thread t : waiters) t.join();
}
}
追问链:
Q1.1: state为什么用volatile int而不用AtomicInteger?
→ state的CAS操作通过Unsafe.compareAndSwapInt直接完成
→ volatile保证可见性,CAS保证原子性,不需要AtomicInteger的额外开销
→ 且AQS需要灵活地做 condition check + CAS 的组合,AtomicInteger的API不够
Q1.2: CLH队列为什么用双向链表?单向不行吗?
→ 双向链表支持从tail向前遍历(unparkSuccessor需要)
→ 取消节点时需要断开prev/next指针,双向链表更方便
→Condition.signal时需要检查节点是否在SyncQueue上,需要prev指针
Q1.3: AQS的模板方法模式体现在哪里?
→ AQS定义了acquire/release的骨架(入队、park、unpark)
→ 子类只需实现tryAcquire/tryRelease定义"能否获取/释放"
→ 类比:AQS是"排队系统",子类是"业务规则"
追问链:
Q2.1: enq入队时,prev和next的设置顺序是什么?
→ node.prev = pred(第一步)
→ CAS(tail, pred, node)(第二步)
→ pred.next = node(第三步)
→ 所以prev先于next被设置
Q2.2: 如果从head往后遍历会怎样?
→ 可能遇到刚入队但next还没设置的节点,认为没有后继,导致漏唤醒
→ 从tail往前遍历,prev已经设置,不会遗漏
Q2.3: 这是不是一个并发bug?
→ 不是bug,是设计上的权衡
→ 入队的"窗口期"内next可能为null,但prev一定已设置
→ 所以从tail遍历是正确的做法
追问链:
Q3.1: 它们底层分别怎么实现的?
→ CountDownLatch基于AQS共享模式,state=计数器
→ CyclicBarrier基于ReentrantLock + Condition,内部维护count和parties
Q3.2: 为什么CountDownLatch用共享模式?
→ 因为await()可能同时有多个线程等待
→ state减到0时,需要一次性唤醒所有等待线程(doReleaseShared传播唤醒)
→ 如果用独占模式,只能唤醒一个
Q3.3: CyclicBarrier为什么能重置?
→ 它不是基于AQS的state,而是自己维护的count
→ 所有线程到达后,调用reset()将count恢复为parties
→ Generation机制处理重置期间的边界情况
1. 以为AQS队列是先进先出就公平 —— 错,非公平锁的tryAcquire可以在队列线程被唤醒前"插队"
2. 以为waitStatus的初始值是SIGNAL —— 错,初始是0,入队后通过shouldParkAfterFailedAcquire才设为SIGNAL
3. 以为Condition await()不释放锁 —— 错,await()会调用fullyRelease()释放锁
4. 以为 park 后线程状态是 BLOCKED —— 错,是 WAITING(LockSupport.park)
5. 手写tryRelease时忘记检查当前线程是否是持有者 —— 导致任何线程都能释放锁
基于SimpleReentrantLock,改造为公平锁版本。
提示:公平锁在tryAcquire时需要先检查 hasQueuedPredecessors()。
基于AQS共享模式,手写一个简单的Semaphore。
提示:tryAcquireShared中 state - arg >= 0 时返回剩余许可,否则返回-1。
使用ReentrantLock + 两个Condition,实现线程A打印奇数、线程B打印偶数,交替输出1-100。
打开JDK源码,跟踪 ReentrantLock.lock() 的完整调用链:
lock() → sync.acquire(1) → tryAcquire(1) → compareAndSetState(0,1)
画出方法调用时序图,标注每一步的类和方法名。