HashMap 并发 put 会丢数据,多线程场景教科书答案就是换 ConcurrentHashMap。但面试官马上追问:它凭什么线程安全?「分段锁」是老黄历了——JDK 8 之后它换了活法,这篇讲清两代设计的进化。
JDK 7:Segment 分段锁。把整张表切成 16 段(Segment),每段自带一把 ReentrantLock。写操作锁住自己那一段,16 段互不干扰——并发度 = 16,写死不可调。像一栋楼 16 个独立办公室,各锁各的门。
JDK 8:CAS + synchronized 锁单桶。结构回归 HashMap 的样子(数组+链表+红黑树),但锁粒度缩到一个桶:
synchronized(桶头节点),只锁这一个桶并发度从固定 16 变成数组长度(还会随扩容涨)。像把 16 个大办公室拆成一层格子间,谁用谁锁哪格。为什么敢用 synchronized?JDK 6 锁升级(7.3 节)之后,这种「持有时间极短」的场景它不输 ReentrantLock,还省一个 Lock 对象的内存。
map.put(k, v); // 内部 putVal,一个大自旋:
// ① 表没建 → CAS 抢初始化权(sizeCtl 置 -1,输家让出 CPU 等)
// ② 桶空 → casTabAt 无锁插入,失败转一圈重来
// ③ 桶头 hash==MOVED → 正在扩容,先去 helpTransfer 帮忙搬
// ④ 否则 synchronized(桶头):再核对桶头没变,链表尾插/红黑树插入
// ⑤ addCount 计数 + 判断要不要扩容
一个细节体现品味:读数组元素不用 tab[i] 而用 getObjectVolatile——数组本身不是 volatile 的,这样只有真正访问的那个桶付可见性代价。
最精彩的设计。触发扩容后,正在 put 的线程不白等,全都拉来搬东西:
1. 每个线程 CAS 领取一段桶(最少 16 个一段),从后往前搬
2. 搬完的桶放一个 ForwardingNode(hash=MOVED),相当于门上贴「已搬走,新址在隔壁」
3. 其他线程 put 到贴条的门 → 主动加入搬家队伍
4. 读线程 get 碰到贴条门 → 顺着指针去新数组找,读完全不阻塞
高并发下几十个线程 CAS 同一个计数器会互相打架。借鉴 LongAdder:一个 baseCount + 一组 CounterCell 分散计数——无竞争走 baseCount,打架了各自写自己的格子,size() 时求和。代价是 sum 的一瞬间可能有并发修改,size() 是弱一致快照,不是精确值。
Node 的 val 和 next 都是 volatile:写入立刻可见,读到的一定是完整节点。加上 ForwardingNode 的「搬家指路」,读操作既不用等锁,也不会在扩容中迷路。
并发下最隐蔽的坑是「先查再改」的两步操作:
// 危险写法:containsKey 和 put 之间,别的线程可能已经塞进去了
if (!map.containsKey(k)) { map.put(k, createValue()); }
// 原子写法:一步到位,不存在才算成功
map.putIfAbsent(k, createValue());
// 更强的一体化家族
map.computeIfAbsent(k, key -> heavyBuild(key)); // 不存在才计算并放入
map.compute(k, (key, old) -> old == null ? 1 : old + 1); // 读改写原子化
map.merge(k, 1, Integer::sum); // 计数器经典写法
merge 一行就是并发安全的词频统计:旧值存在就加一,不存在就放 1,整个过程锁住的是同一个桶,别的线程插不进来。把「判断+计算+写入」交给容器一次做完,是并发容器的正确打开方式。
size() 是弱一致的(求和瞬间可能有人在改),遍历也是——迭代器反映的是「创建时或之后的某个状态」,不保证全程快照。并发包的哲学是读操作永不阻塞,代价就是读到的不是强一致视图。需要强一致的场合(比如对账),要么加外部锁,要么改用数据库事务。
computeIfAbsent 最典型的舞台是本地缓存:
ConcurrentHashMap<String, Order> cache = new ConcurrentHashMap<>();
Order hit = cache.computeIfAbsent(orderId, // 同 key 只有一个线程执行
id -> queryFromDb(id)); // 查库并回填
cache.remove(orderId); // 下单后失效,下次重查
妙处在同桶互斥:一百个并发请求同一个 key,只有第一个真正查库,其余在桶锁外等结果,到手直接走——数据库只被穿透一次。对比「先 get 判空、没有再 put」的两步写法:并发下 N 个线程同时判空,N 次查库全打穿,这正是缓存击穿的教科书成因,computeIfAbsent 天然免疫。
三条使用纪律。一,lambda 里不要再碰这张 map:可能和自己抢同一把桶锁,死锁给看(官方文档点名的坑)。二,lambda 别做太慢的事:它占着桶锁,同桶其他 key 的读写全被拖住。三,返回的可能不是你算的那个:别人先放好了,你拿到的是别人的成果——这恰是正确行为,别惊讶。
这个模式加上「记录写入时间、读时懒淘汰」就是带过期的简易缓存;Guava Cache、Caffeine 的并发骨架同源,只是把淘汰、统计、刷新都补齐了。
CHM 源码里绕不开的字段 sizeCtl(表控制位),一个 int 身兼四职,是读代码的第一道坎:
妙处是判断表状态不用额外标志位,读一个变量全知道——省内存的极致操作。put 路线里的 CAS 抢初始化权,抢的就是把它改成 -1。面试被问「CHM 怎么记录并发状态」,答出 sizeCtl 四重身份,是读过源码的硬信号。顺带一提:初始化没抢到权的线程让出 CPU 后自旋重看,不阻塞挂起。
getOrDefaultif (!map.containsKey(k)) map.put(k, v) 并发下会双写,用 putIfAbsent / computeIfAbsent 一体化方法map.get 后基于旧值算再 set 回去仍然有竞态,用 compute / mergeConcurrentHashMap 从 16 把大锁进化到「空桶 CAS、占桶才锁、读写不挡路」:put 能顺手帮着扩容,计数分散打格子,get 全程无锁——细粒度到桶,就是它快的全部秘密。