AQS 的 state 和 ConcurrentHashMap 的 sizeCtl,本质是同一个东西
面试题经常把 AQS、ConcurrentHashMap、对象头分开问,好像它们是三个独立的知识点。
但如果你把源码摆在一起看,会发现它们用的是同一个套路:用一个 volatile 的 int 记录状态,用 CAS 去改它,改不动就排队等着。
理解了这一句,三个东西就不再是硬背的知识点,而是同一个思路的三种应用。

一、AQS:一个 state 加一条队列
AbstractQueuedSynchronizer 这个名字很唬人,但它的核心就两个字段:
public abstract class AbstractQueuedSynchronizer {
private volatile int state; // 状态
private transient volatile Node head; // 队列头
private transient volatile Node tail; // 队列尾
}
没了。就这么多。
state 的含义,由子类定义
这是 AQS 设计上最巧的一点:它自己不给 state 赋予语义,全靠子类解释。
| 实现类 | state 表示什么 |
|---|---|
ReentrantLock | 重入次数。0 = 未锁,1 = 锁了一次,2 = 重入了 |
Semaphore | 剩余许可数 |
CountDownLatch | 还剩几个任务没完成 |
ReentrantReadWriteLock | 高 16 位读锁数,低 16 位写锁数 |
所以 AQS 提供的是"排队机制",不是"锁语义"。语义由子类通过 tryAcquire / tryRelease 自己实现。
抢不到锁的线程去哪了
进 CLH 队列排队,然后 park 挂起。
流程(以 ReentrantLock.lock() 为例):
lock()
→ tryAcquire(state) // 子类实现,尝试 CAS 改 state
├─ 成功 → 直接返回,不进队列
└─ 失败
→ addWaiter() // 包装成 Node,插到队尾
→ acquireQueued() // 自旋 + park
├─ 前驱是 head 且 tryAcquire 成功 → 出队,成为新 head
└─ 否则 park 挂起
acquireQueued 里有个细节:只有前驱节点是 head 的线程才会去尝试抢锁,其它节点老老实实 park。这样避免了所有等待线程同时被唤醒又同时失败的"惊群"。
释放时:
unlock()
→ tryRelease() // state 减到 0
→ unparkSuccessor(head) // 只唤醒队列里的下一个
独占 vs 共享
AQS 支持两种模式,区别在"抢到之后要不要把资源让出来":
独占模式:同一时刻只有一个线程能持有。
tryAcquire/tryReleaseReentrantLock
共享模式:多个线程可以同时持有。
tryAcquireShared/tryReleaseSharedSemaphore、CountDownLatchReadWriteLock的读锁
共享模式的传播特性很有意思:一个线程抢到共享资源后,会继续唤醒后面的共享节点,因为资源还有剩余。
公平锁和非公平锁,差在哪一行
// 非公平锁
final void lock() {
if (compareAndSetState(0, 1)) // 先抢一次,不管有没有人排队
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
// 公平锁
final void lock() {
acquire(1); // 直接走 acquire,会检查队列
}
非公平锁在入队之前,会先 CAS 抢一次。 如果刚好这一刻锁释放了,它就能插队成功。
这是非公平锁吞吐量更高的原因——减少了线程唤醒和上下文切换。代价是可能"饿死"队列里的线程(概率很低,因为要恰好撞上释放的瞬间)。
tryAcquire 里还有一处区别:公平锁会多判断一个 hasQueuedPredecessors(),队列里有人排队就不抢。
二、ConcurrentHashMap:锁最小的那一块
JDK 7 和 JDK 8 的实现差别很大,面试基本都会问"为什么要改"。
JDK 7:Segment 分段锁
final Segment<K,V>[] segments; // 默认 16 段
每个 Segment 继承 ReentrantLock,锁的粒度是"一段"。理论并发度是 16。
问题:内存开销大(每个 Segment 都是一整个 HashMap 结构),而且 16 这个数字写死了,扩容也不方便。
JDK 8:CAS + synchronized 锁桶头
transient volatile Node<K,V>[] table; // 就是一个 Node 数组
锁的粒度降到单个桶的头节点。并发度等于数组长度(默认 16,可以扩到很大)。
关键变化:用 synchronized 而不是 ReentrantLock。
原因有两个:
- synchronized 在 JDK 6 之后有偏向锁/轻量级锁优化,无竞争时开销极低
- 锁的只是"一个桶的插入操作",临界区极短,重量级锁的膨胀风险很小
put 的四个分支
final V putVal(K key, V value, boolean onlyIfAbsent) {
// ① 表为空 → CAS 设置 sizeCtl,initTable
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// ② 桶为空 → CAS 直接放,不加锁
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
break;
}
// ③ 桶头 hash == MOVED(-1) → 正在扩容,帮着搬
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// ④ 桶有节点 → synchronized 锁住头节点
else {
synchronized (f) {
// 链表插入 或 红黑树插入
}
}
}
四个分支对应四种并发场景,这就是它比 Hashtable 快两个数量级的原因——Hashtable 是整张表一把锁。
扩容:多线程一起搬
这是 JDK 8 最精妙的地方。扩容不是一个人搬,是所有写线程一起搬。
sizeCtl为负数时,表示正在扩容。高 16 位是扩容戳,低 16 位是参与线程数- 每个线程领一个区间(stride),搬完了就继续领下一个
- 搬完的桶放一个
ForwardingNode(hash = MOVED),别的线程看到就知道"这个桶搬过了"
所以 sizeCtl 这个字段同时承担了三件事:初始化阈值、扩容阈值、扩容状态。这也是它必须是负数才能表示"扩容中"的原因。
size 是怎么算的
private transient volatile long baseCount;
private transient CounterCell[] counterCells;
直接用一个 AtomicLong 在高并发下会成为热点(所有线程抢同一个 CAS)。所以用了分段计数:
- 无竞争:直接 CAS 改
baseCount - 有竞争:分配一个
CounterCell,各自累加 - 求和:
baseCount+ 所有CounterCell的值
这跟 LongAdder 是同一个思路。
为什么不允许 null 键和 null 值
HashMap 允许,ConcurrentHashMap 不允许。
原因是并发下的二义性:get(key) 返回 null,你无法区分"这个 key 不存在"还是"这个 key 存在但值是 null"。
单线程下可以 containsKey 再判断,但并发下这两步之间状态可能变了。所以直接禁止 null,让 get 返回 null 就等价于"不存在"。
三、4 字节的 ClassPointer 为什么够用
这一节讲对象头,很多人不知道它和上面有什么关系——其实关系很大:压缩指针是"用位运算换内存",和 AQS 用 state 换锁,是同一种思路。
64 位 JVM 下的对象头
| Mark Word (8 字节) | Klass Pointer (4 或 8 字节) | 实例数据 | 对齐填充 |
Klass Pointer 指向方法区里的类元数据。64 位下本来要 8 字节。
压缩原理:低 3 位是白送的
JVM 要求对象起始地址按 8 字节对齐(因为要配合 CPU 缓存行)。
这意味着任何对象地址的低 3 位都是 0:
地址: 0x0000_0001_2345_6788
↑↑↑ 永远是 000
既然这三位永远是 0,存的时候就可以省掉。压缩后的 4 字节存的是"地址除以 8":
存储值 = 真实地址 >> 3
还原 = 存储值 << 3
4 字节 = 32 位,能表示 2³² 个"8 字节单位" = 32GB。
32GB 魔咒
堆一旦超过 32GB,4 字节装不下所有地址,压缩自动失效,指针变回 8 字节。
结果:
- 每个对象的引用字段变大 → 对象变大 → 同样的数据占更多内存
- 缓存命中率下降 → 性能反而更差
所以 JVM 调优有一条经验:堆要么小于 32GB,要么远大于(比如 48GB、64GB),别卡在 32~48 之间。
相关参数:
-XX:+UseCompressedOops # 压缩对象引用(默认开启)
-XX:+UseCompressedClassPointers # 压缩 Klass Pointer(默认开启)
-XX:ObjectAlignmentInBytes=8 # 对齐字节数,改成 16 可以让 4 字节省到 64GB
最后那个参数很少人知道:把对齐从 8 改成 16,压缩指针的寻址范围就翻倍到 64GB。代价是对象内部可能有更多填充浪费。
怎么确认是否生效:
java -XX:+PrintFlagsFinal -version | grep UseCompressedOops
四、三个东西的同一个思路
把这三节摆在一起看:
| 记录状态的字段 | 怎么改 | 改不动怎么办 | |
|---|---|---|---|
| AQS | state(int) | CAS | 进 CLH 队列 park |
| ConcurrentHashMap | sizeCtl(int) | CAS | 帮着扩容 / 锁桶头 |
| 压缩指针 | 地址 >> 3(int) | 位运算 | —— |
前两个是同一个模板:一个 volatile int 当状态位,CAS 当乐观锁,失败才走悲观路径。
这个模板的好处是:绝大多数情况下(无竞争)只花一次 CAS 的代价,不需要真正加锁。
这也是为什么 ConcurrentHashMap 读操作完全不加锁(get 只读 volatile),写操作只在桶冲突时才 synchronized。
面试怎么答
如果被问"AQS 原理",别一上来背 acquire 流程。先说这一句:
AQS 是一个基于 volatile int state 和 CLH 双向队列的同步框架。state 的语义由子类定义,AQS 只负责"抢不到就排队、释放就唤醒"这套机制。
然后再展开 tryAcquire、addWaiter、park/unpark。这个顺序能让面试官立刻知道你懂的是设计,不是流程。
如果被问"ConcurrentHashMap 为什么快",重点说三句:
- 锁粒度从"整表"降到"单个桶头"
- 读操作完全无锁(volatile 读)
- 扩容支持多线程协作,不是一个人搬
这一节对应课程 1-6「AQS 到底是啥」、1-9「ConcurrentHashMap 的…」和 1-8「Java 中 4 字节的 ClassPointer」,三节连起来看,正好能把"并发 + JVM 内存布局"这条线串通。

想要这套笔记 + 源码调试记录的,扫码加我,备注「Java」👇

不用转发、不用关注,加上直接发你。
615



被折叠的 条评论
为什么被折叠?



