ConcurrentHashMap、TransferQueue 与 CopyOnWrite:桶级并发、直通 handoff 与写时复制的选型边界

ConcurrentHashMap、TransferQueue 与 CopyOnWrite:桶级并发、直通 handoff 与写时复制的选型边界

Hello,我是小兔大白糖。 本地缓存一上多线程就偶发丢更新;事件队列一堆,P99 毛刺上来;配置白名单一热更,GC 又跟着抖——排障到最后,常常不是「再加一把大锁」,而是并发容器各自买什么、卖什么没写清。写成这篇,给熟悉线程池、JMM、volatile / 锁,却还把 ConcurrentHashMap 当「完全无锁 HashMap」的后端同学:做一次业界向的并发集合选型调研。

说明:伪流程与场景均为教学脱敏 / 示意,不绑定某司业务栈。读完带走的是心智模型与取舍清单,不是备考提纲。

估计阅读时间:11 分钟


目录


为什么现在要关心

并发容器解决的是「多线程共享可变集合时,正确性与吞吐的合同」——不是「贴上 Concurrent 前缀就自动安全」。

现场里常见的误伤:

你看到的现象常见真相
get 判空再 put,「偶发」覆盖check-then-act 不是原子;要 putIfAbsent / compute / merge
直通队列一忙,生产者全堵住transfer 等消费者;消费者不足时账单在写路径
配置列表用 CopyOnWrite,写一多就 Full GC每次写复制整表;写频繁时延迟与 GC 一起爆
把无界队列当 inbox,内存慢慢顶到 OOM缓冲合同没写容量与背压
「CHM 完全无锁」却在 compute 里打远程桶锁仍在;慢逻辑会拖同桶竞争者

和本系列前面几篇同一类问题:你以为在挑「更快的集合」,其实在谈失败形态是否可预期。本文钉三件事——桶级并发的边界、直通 handoff 的代价、写时复制适合谁。


心智模型:三车道

主比喻:共享可变集合是一条要分车道的公路——键值高并发走 ConcurrentHashMap,低延迟直通走 TransferQueue,读多写极少走 CopyOnWrite。

普通 HashMap / ArrayList 像没有分道的羊肠路:多人同时改结构,JDK 7 时代扩容还能把链表拧成环;粗锁包装(Hashtable、Collections.synchronizedXxx)像整条路只开一个收费口——正确,但吞吐差。

三车道选型:高并发键值走 ConcurrentHashMap,低延迟直通走 LinkedTransferQueue,读多写极少走 CopyOnWrite 列表
三车道选型:高并发键值走 ConcurrentHashMap,低延迟直通走 LinkedTransferQueue,读多写极少走 CopyOnWrite 列表 · 点击查看 SVG 原图
比喻角色容器对应人话
分车道收费站ConcurrentHashMap 桶级锁 / CAS不同键常可并行;同桶仍会碰头
外卖直送(手递手)LinkedTransferQueue.transfer生产者交给已在等的消费者;延迟低,缓冲弱
每人发一份复印件CopyOnWriteArrayList / CopyOnWriteArraySet读无锁看快照;写贵,适合极少变更

类比局限一句说清:三车道解释「读写形态与账单」;解释不了跨键事务、业务幂等,也解释不了「这个丢更新能不能赔得起」——那是 SLA,不是集合 API 条款。


精确定义:三条硬边界

先问读写形态与失败形态,再选容器;别先贴 Concurrent 前缀当护身符。

1)ConcurrentHashMap:桶级并发,不是「完全无锁 HashMap」

公开演进(分享向够用):

阶段并发机制(人话)粒度
JDK 7Segment 分段锁默认约 16 段上限
JDK 8+CAS 插空桶 + synchronized 桶头;链表过长可树化桶级;get 路径通常无锁、靠 volatile 可见

硬边界:

  1. 单键读写与多数原子 API 可并发——不同桶互不挡;同桶竞争仍要排队。
  2. 复合操作(check-then-act)仍要原子 API 或外层同步——get + put 拼不出 putIfAbsent 语义。
  3. 迭代是弱一致快照叙事——遍历中可能看见部分更新;需要稳定视图就先拷贝(大 Map 有代价)。
  4. size() / mappingCount() 是近似——高并发下不为精确账本设计;精确计数另找合同。

树化阈值(OpenJDK 常见常量:链表 ≥ 8 且表长 ≥ 64 才树化,过稀可退回链表)属于实现细节;选型带走的是——极端冲突会变贵,哈希质量与容量规划仍重要。[TECH-CHECK:具体常量以目标 JDK 源码为准]

2)LinkedTransferQueue:直通 handoff,不是无限 inbox

TransferQueue(可转移队列) 在「有人已经在等」时,可以把元素直接交给对方(handoff),少绕一圈大缓冲。

硬边界:

  1. transfer / 限时 tryTransfer:阻塞或超时直到被取走——低延迟传递;消费者不足时拖写端。
  2. offer / put / add:可入队,队列无界——能缓冲,但别默认当成「无限可靠 inbox」。
  3. 别和 SynchronousQueue 混为一谈——后者容量语义更「严格手递手、几乎不存货」;前者还能当无界队列用,API 更富。
  4. 适合事件直通;不适合「先堆几天再慢慢消费」的大缓冲叙事。

3)CopyOnWrite:读无锁、写复制

硬边界:

  1. 读路径(get / 迭代)看当前数组快照,通常无锁——读多时友好。
  2. 写路径加锁并复制整表再替换引用——写频率一高,分配与 GC 账单线性涨。
  3. 迭代器是快照:不抛 ConcurrentModificationException,也可能读到旧数据——合同如此,不是 bug。
  4. 只适合读多写极少(配置、白名单、监听器列表一类);高频追加日志别用。

模式对照:CHM、TransferQueue、CopyOnWrite

业界常见三条路:键值并发缓存、低延迟直通、读多写少快照——每条都有代价。

选型分流:要跨键事务别硬扛 CHM;写极少用 CopyOnWrite;要缓冲用有界队列,要直通用 TransferQueue
选型分流:要跨键事务别硬扛 CHM;写极少用 CopyOnWrite;要缓冲用有界队列,要直通用 TransferQueue · 点击查看 SVG 原图
容器适用你多买到什么主要代价 / 别用在
ConcurrentHashMap本地缓存、分片计数、单键状态机桶级并行;compute / merge 等原子更新跨键强一致事务;在持桶计算里做慢 IO
LinkedTransferQueue生产者-消费者直通、低延迟事件有人在等时可 handoff;API 覆盖 transfer / 普通入队当无限堆积缓冲;消费者不足时拖垮写端
有界 BlockingQueue(对照)需要明确容量与背压堆积上限可预期选错容量会拒收或阻塞;延迟通常高于直通
CopyOnWriteArrayList / Set配置 / 白名单 / 监听器热更读无锁快照写频繁;大列表每次复制

分享向默认推荐:

  • 高并发键值、可接受单键原子语义 → ConcurrentHashMap + 原子 API。
  • 要低延迟、消费者跟得上 → transfer / tryTransfer;跟不上就限时降级或换有界队列。
  • 几乎只读、偶尔整表替换 → CopyOnWrite 或「不可变列表 + volatile 引用替换」(后者常更直观)。
  • 要跨多键事务 → 别用 CHM 硬扛;上锁、单线程分区、或外置事务存储。

代价必须写进选型:CHM 买并发,卖的是「复合操作仍要你自己原子化」;TransferQueue 买直通,卖的是写端可能被消费者拖住;CopyOnWrite 买读吞吐,卖的是写复制与旧快照可见。


教学场景:缓存、直通、白名单

三个最小场景;代码刻意少,结论应能离开代码独立成立。

1)本地缓存 / 分片计数——CHM + 原子 API

教学伪流程:

# 错误:check-then-act
if (map.get(k) == null) map.put(k, load(k))   # 两线程可双载

# 方向:原子懒加载 / 合并
map.computeIfAbsent(k, this::load)
map.merge(k, delta, Integer::sum)

适合:进程内画像缓存、路由规则句柄、单键计数。
不适合:compute 里查库、调 RPC——桶被占住,同桶吞吐塌掉。慢路径先算完,再短 compute 合并。

需要 LRU / 精确 TTL 淘汰时,业界更常上 Caffeine 一类专用缓存,而不是手搓「CHM + 自己维护访问链」。

2)事件直通——TransferQueue

producer:  tryTransfer(event, timeout)   # 有人在等 → 直接交;超时 → 降级
           # 或 offer(event)             # 入队,不保证立刻被拿走
consumer:  take() / poll(timeout)

适合:延迟敏感、消费者池容量跟得上的流水线。
不适合:把无界 offer 当无限邮箱——堆到 OOM 时,合同才第一次被看见。

对照:只要「一对一交换、几乎不缓冲」,评估 SynchronousQueue(线程池工作队列常见);要 transfer 语义又偶尔允许入队,再看 LinkedTransferQueue。

3)白名单 / 配置快照——CopyOnWrite 或 volatile 引用

readers:  for (rule : rules) match(...)     # 无锁读当前快照
writer:   rules = copyAndAdd(...)           # 写锁复制;或直接替换整个不可变 List 引用

适合:分钟级或更低频变更、读路径极热。
写一多:优先「构建新不可变结构 + volatile 发布引用」,或换普通列表 + 读写锁——别死守 CopyOnWrite。


常见坑

  1. 用 get + put 拼 putIfAbsent / 懒加载
    看得见最新值,拦不住两人同时通过「还没有」的窗口。

  2. 在 compute / merge 里做耗时 IO
    桶级锁仍在;慢逻辑变成同桶串行器。

  3. 把 LinkedTransferQueue 当无限 inbox
    无界堆积是能力也是陷阱;要容量合同就用有界队列 + 拒绝 / 阻塞策略。

  4. transfer 无超时,消费者挂了写端一起挂
    生产路径用 tryTransfer + 降级(入有界队列、落盘、打点告警)更可控。

  5. CopyOnWrite 当消息缓冲 / 高频日志
    每秒上千次写 = 每秒上千次整表复制;GC 与尾延迟一起爆炸。

  6. 把 CHM 迭代当成强一致全表快照
    弱一致是设计;审计导出先拷贝或换只读发布。

  7. 用 size() 做精确限流门槛
    近似值 + check-then-act 清缓存,窗口里状态已变;限额用原子计数或外置限流器。


选型结论

  1. 先问读写形态:键值高并发 → CHM;低延迟直通 → TransferQueue;读多写极少 → CopyOnWrite / 不可变快照。
  2. ConcurrentHashMap = 桶级并发 + 原子 API;不是跨键事务引擎,也不是「完全无锁」。
  3. transfer 买直通、卖写端阻塞风险;要堆积上限就显式有界队列,别默默无界。
  4. CopyOnWrite 买读无锁、卖写复制;写频率爬升就换发布模型。
  5. 用「失败形态」复述设计:丢更新、拖垮写端、OOM、GC 毛刺——说不清哪一种可接受,就还没选型完。

下一步:把进程内共享集合列一张表——每项标「读写比 / 要不要复合原子 / 要不要有界 / 跨键事务?」→ 能降成不可变快照的先降 → 单键走 CHM 原子 API → 直通走限时 transfer → 其余有界队列或短临界区收口。

系列导航: