结论先行:JDK 8 的 ConcurrentHashMap 把 JDK 7 的分段锁(Segment)整体砍掉,改成「CAS + synchronized 锁单个桶头节点」,锁粒度从「一段 16 个桶」细化到「一个桶」,读操作完全无锁。理解这个结构变化,比背接口用法重要得多——线上大多数 ConcurrentHashMap 相关的问题,根因都不在「它不安全」,而在「它的安全是有边界的」。

JDK 7:分段锁的问题

JDK 7 把整个数组拆成若干 Segment(默认 16 个),每个 Segment 继承 ReentrantLock,写操作锁整个段。并发度上限被 Segment 数量写死,段内竞争再激烈也只能等锁,且定位元素要做两次哈希(先定位段、再定位段内桶)。分段锁是那个年代在「一把全局锁」和「无锁」之间的务实折中,但它有两个结构性缺陷:一是并发度在构造时固定,初始化之后无法随流量调整;二是锁的粒度与数据分布无关——哪怕 16 个段里只有 2 个段有数据,竞争一样发生在这 2 个段的锁上。

顺带补一个遗留知识点:JDK 7 构造方法里的 concurrencyLevel 参数只影响初始段数,不等于并发上限的承诺——段数必须是 2 的幂且初始化后不再变化。迁移旧代码时看到这个参数,按「历史兼容」理解即可,JDK 8 里它已经被彻底忽略。

JDK 8:锁粒度降到桶级别

新结构是 Node 数组 + 链表/红黑树,put 的加锁逻辑分三步(节选自 putVal,有删减):

// 1. 桶为空:CAS 写入,完全不加锁
if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
    if (casTabAt(tab, i, null, new Node<>(hash, key, value)))
        break;
}
// 2. 桶头节点 hash == MOVED:正在扩容,先帮忙迁移数据
else if ((fh = f.hash) == MOVED)
    tab = helpTransfer(tab, f);
// 3. 其余情况:synchronized 锁住头节点
else {
    synchronized (f) { /* 遍历链表或操作红黑树插入 */ }
}

桶为空时一个锁都不用拿;非空才 synchronized 头节点,冲突面缩小到同一个桶。锁的是头节点这个事实还有一层含义:不同桶的写操作完全并行,同一桶内才串行。这就是 JDK 8 高并发的核心来源。扩容还支持多线程协助迁移(helpTransfer):线程 put 时发现正在扩容,不等着,而是领一段桶区间帮忙搬数据,搬完再做自己的写操作,大表扩容不再是单线程扛。两个版本的差异集中在一张表里:

维度JDK 7 分段锁JDK 8 CAS + synchronized
锁实现Segment(继承 ReentrantLock)CAS + synchronized 锁桶头节点
锁粒度一个段(默认 16 个桶)一个桶
定位元素两次哈希(先段后桶)一次哈希
扩容段内独立扩容多线程协助迁移 helpTransfer
计数各段独立计数,读取时汇总baseCount + CounterCell 分散热点
空桶写入也要拿段的锁CAS 直接写入,无锁

读为什么可以无锁

Node 的 val 和 next 都声明为 volatile,get 全程不加锁,靠 volatile 的可见性保证读到最新值;数组本身的引用也是 volatile 的,扩容换表后读线程能立刻看到新表。这也是它不允许 null key/value 的原因之一:并发环境下 get 返回 null 时,无法区分「key 不存在」和「value 就是 null」(HashMap 单线程可以先 containsKey 再 get,并发下这个两步操作会被穿插),二义性问题干脆用禁止 null 解决。需要「值可能为 null」的语义时,用 Optional 包装或者哨兵对象表达,而不是换回 HashMap 再自己加锁。

懒初始化也是 put 路径的一部分:table 在首次写入时才创建,容量由 sizeCtl 控制,多线程同时初始化靠 CAS 抢占 sizeCtl 保证只有一人执行。加上 Unsafe 层面的 tabAt/setTabAt 提供数组元素的 volatile 语义(普通 Java 数组做不到),这套「无全局锁完成初始化、扩容、写入」的组合,是读源码时最值得细读的部分。

size 统计:借鉴 LongAdder

计数没有用一个 volatile 变量硬扛,而是 baseCount 加 CounterCell 数组分散热点:没有竞争时 CAS 更新 baseCount,竞争激烈时各线程更新自己的 CounterCell,求和时再汇总。直接对着单个变量 CAS,高并发下失败率极高,这个思路和 LongAdder 一致,值得借鉴到自己的计数场景。代价是 sum 返回的是「某个时刻的近似值」——统计过程中其他线程还在写。JDK 8 之后官方还提供了 mappingCount(),返回 long:size() 返回 int,元素超过 21 亿会溢出,虽然极端,但 API 设计上把 long 版本单独给了出来。

这套分段计数的代价也不小:CounterCell 数组同样占用内存(懒创建、按需填充),并用 @Contended 注解避免伪共享。设计权衡是「写多读少时近乎免费,读取时变贵」,恰好匹配元素高频增删、size 低频统计的真实负载——照搬到自己的高频计数场景前,先确认读写比例是同构的。

三个实战误区

一是复合操作不是原子的,「get 判空再 put」中间可能被其他线程插入,应该用 putIfAbsent 或 computeIfAbsent:

// 错误写法:check-then-act 两步之间会被穿插
List<String> list = map.get(k);
if (list == null) {
    list = new ArrayList<>();
    map.put(k, list);   // 两个线程可能同时走到这里,后写的覆盖先写的
}
list.add(v);            // 先判空的线程往将被丢弃的实例里 add,元素静默丢失

// 正确写法:原子化的「不存在则创建」
map.computeIfAbsent(k, key -> new ArrayList<>()).add(v);

二是 size() 在并发写时只是近似值,需要精确计数请自己控制同步,或者把计数职责从 Map 里剥离出去单独做。三是迭代器是弱一致性的,遍历时其他线程的修改可能看到也可能看不到,不会抛 ConcurrentModificationException,这是设计而非 bug——不要把「遍历结果完整」当作业务前提。

把几个误区合并起来看,规律是同一条:ConcurrentHashMap 只承诺「单次方法调用原子」,任何跨调用的推理(两次 get 比较、遍历后统计、先查后写)都需要额外的同步设计。把它理解成「线程安全的 HashMap」然后按单线程思维拼装逻辑,是绝大多数线上问题的起点。

一句话总结使用姿势:把它当「每步原子」的并发容器用,别当「整段逻辑原子」的同步工具用——后者的正确工具是锁,前者才是 ConcurrentHashMap 的设计目标。

还有第四个隐性成本容易忽略:computeIfAbsent 的映射函数执行期间,同一个桶的头节点是被锁住的。往映射函数里塞慢调用(RPC、DB 查询),所有 hash 落到同一个桶的 key 都会被串行阻塞:

// 错误写法:慢 IO 放进映射函数,同桶请求被串行拖住
map.computeIfAbsent(cacheKey, k -> remoteQuery(k)); // 下游一抖,同桶全部超时

// 正确写法:慢调用放在锁外,映射函数只负责把结果放进去
List<Price> cached = map.get(cacheKey);
if (cached == null) {
    List<Price> fresh = remoteQuery(cacheKey);       // 慢调用在锁外执行
    cached = map.computeIfAbsent(cacheKey, k -> fresh);
}

更彻底的方案是直接用 Caffeine 这类本地缓存库,加载逻辑、过期、并发控制都替你做好了。

生产案例

某聚合查询服务用 ConcurrentHashMap 做本地结果缓存,映射函数里封装了一次下游 RPC。平时流量低相安无事,大促当天下游响应时间整体抬高后,接口出现规律性的超时毛刺:同一个桶上的 key 互相等着,一个慢请求拖住后续所有映射。排查时先看下游监控,响应时间只是「变慢」,不至于直接超时;再用 arthas 观察入参 hash 的分布,发现热点 key 大量落在同一批桶上。整改把慢调用挪到映射函数之外,先 get 后 computeIfAbsent 只负责写入,同时给缓存加了 Caffeine 的容量上限和过期时间。这次案例的教训是:ConcurrentHashMap 的锁粒度是桶,任何「一个 key 的操作拖住另一个 key」的写法,先查一下这两个 key 是否同桶。