在多线程并发环境中,java 线程安全的map是指在并发读写操作下仍能保证数据一致性、可见性与原子性的Map实现。Java标准库提供了多种线程安全Map方案,每种方案在并发性能、内存占用、功能完整性及适用场景上存在显著差异。
从JDK 1.2起,java.util.Hashtable作为早期线程安全Map被引入,其通过全局同步机制确保线程安全,但高竞争下性能极差;JDK 5引入java.util.concurrent包后,ConcurrentHashMap成为主流选择,采用分段锁(JDK1.7)与CAS + synchronized(JDK1.8+)策略,在保证线程安全的同时大幅提升了并发吞吐量。
值得注意的是,java 线程安全的map不仅需满足线程安全,还应兼顾:
• 原子性:如putIfAbsent、computeIfAbsent等复合操作的原子执行
• 弱一致性迭代:迭代器不抛ConcurrentModificationException,但可能反映部分更新
• 可扩展性:支持高并发读写,避免锁争用热点
在实际开发中,误用非线程安全Map(如HashMap)是导致并发Bug的常见根源。例如:
• 多线程同时扩容时可能形成环形链表,导致get操作死循环
• 读写竞争引发数据丢失或重复覆盖
• 迭代过程中结构变更导致ConcurrentModificationException
ConcurrentHashMap —— 高并发首选java 线程安全的map中,ConcurrentHashMap是JDK 1.5后最推荐的实现。其核心演进如下:
JDK 1.7采用Segment分段锁机制:
• 整体结构为Segment[]数组,每个Segment继承自ReentrantLock
• 锁粒度为Segment,默认16个段,理论并发度为16
• 每个Segment内部为HashEntry[]数组 + 链表结构
// JDK 1.7核心结构示意
static final class Segment extends ReentrantLock implements Serializable {
transient volatile HashEntry[] table;
transient int count;
...
}
static final class HashEntry {
final int hash;
final K key;
volatile V value;
volatile HashEntry next;
}
优势:锁分离降低争用
局限:段数量固定,扩容需整体迁移,内存开销较大
JDK 1.8彻底重构:
• 移除Segment,采用与HashMap类似的数组+链表/红黑树结构
• 锁粒度降至桶(node)级别,仅对首节点加synchronized
• 大量使用CAS操作(如compareAndSwapInt)实现无锁化更新
// JDK 1.8 putVal核心逻辑片段
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
int binCount = 0;
for (Node[] tab = table;;) {
Node f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// CAS插入空桶:无锁
if (casTabAt(tab, i, null, new Node(hash, key, value, null)))
break;
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
// 对首节点加synchronized:细粒度锁
synchronized (f) {
...
}
}
}
addCount(1L, binCount);
return null;
}
优势:
• 内存占用降低30%以上
• 扩容采用迁移协议(ForwardingNode),支持并发扩容
• 红黑树优化:链表长度≥8且数组≥64时转树
JDK 1.9+进一步精简:
• 移除Segment相关冗余代码
• 优化size()方法:采用双计数器baseCount + CounterCell[]
• 改进树化策略:避免频繁树化/退化
性能对比(16线程写入100万条数据):
• JDK 1.7:ConcurrentHashMap耗时约1280ms
• JDK 1.8:ConcurrentHashMap耗时约720ms(提升44%)
Hashtable —— 历史遗留方案Hashtable是Java最早提供的线程安全Map,其核心特征:
• 所有方法均用synchronized修饰,全局独占锁
• 不支持null键或值(抛NullPointerException)
• 迭代器为强一致性,结构变更时抛ConcurrentModificationException
Hashtable?ConcurrentHashMap的4.4倍)rehash过程不可中断computeIfAbsent等现代API// Hashtable的同步机制
public synchronized V put(K key, V value) {
// ... 省略空值检查
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
// ...
}
Collections.synchronizedMap —— 包装器方案通过Collections.synchronizedMap(new HashMap<>())包装非线程安全Map,其本质是:
• 返回SynchronizedMap内部类,所有方法通过synchronized(this)同步
• 同步粒度为整个Map对象,性能与Hashtable相当
Iterator it = m.keySet().iterator(); synchronized(m) { while(it.hasNext()) ... }
适用场景:低并发环境或临时兼容旧代码
ConcurrentSkipListMap —— 有序线程安全Map基于跳表(Skip List)实现的有序Map,特点:
• 全局有序:支持firstKey、lastKey、subMap等操作
• 高并发读写:读操作无锁,写操作基于CAS
• 时间复杂度:get/put/remove均为O(log n)
ConcurrentSkipListMap?tailMap等子Map操作频繁性能对比(100万数据,读写比7:3):
• ConcurrentHashMap:185ms
• ConcurrentSkipListMap:242ms(慢31%)
• TreeMap(非线程安全):142ms
| 特性 | ConcurrentHashMap |
ConcurrentSkipListMap |
Hashtable |
Collections.synchronizedMap |
HashMap(非安全) |
|---|---|---|---|---|---|
| 线程安全 | ✅ 是 | ✅ 是 | ✅ 是 | ✅ 是 | ❌ 否 |
| 有序性 | ❌ 无序 | ✅ 有序(自然排序) | ❌ 无序 | ❌ 无序 | ❌ 无序 |
| 允许null键/值 | ❌ 键值均不允许 | ❌ 键值均不允许 | ❌ 键值均不允许 | ✅ 允许(包装后) | ✅ 允许(单null键) |
| 高并发性能 | ★★★★★ | ★★★☆ | ★☆ | ★☆ | N/A |
| 内存开销 | 中 | 高(跳表冗余指针) | 低 | 低 | 最低 |
| 迭代一致性 | 弱一致性 | 弱一致性 | 强一致性 | 强一致性 | 强一致性 |
| 现代API支持 | ✅ computeIfAbsent等 | ✅ computeIfAbsent等 | ❌ 仅基础API | ✅ 包装后继承 | ✅ JDK8+支持 |
| 推荐场景 | 高并发无序场景 | 高并发有序场景 | 低频读写+兼容 | 临时过渡方案 | 单线程环境 |
测试环境:Intel i7-12700H / 32GB RAM / JDK 17
测试负载:16线程并发,100万次操作(读70% / 写30%)
| 操作类型 | CHM |
CSLM |
HT |
SynchronizedMap |
|---|---|---|---|---|
| put | 8.2 | 12.7 | 24.1 | 23.8 |
| get | 3.1 | 5.6 | 18.3 | 17.9 |
| remove | 7.8 | 11.2 | 22.5 | 22.1 |
| size | 0.05 | 0.08 | 0.12 | 0.11 |
| 迭代10万条 | 12.3 | 18.7 | 21.4 | 20.9 |
sizeCtl控制变量sizeCtl是ConcurrentHashMap的核心状态标识:
• < 0:初始化中,值为-1(初始化)或-(1+n)(扩容线程数)
• = 0:未初始化,使用默认容量
• > 0:初始化容量或下一次扩容阈值
// 初始化时的关键逻辑
private final Node[] initTable() {
Node[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield(); // 正在初始化,等待
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node[] rt = (Node[])new Node,?>[n];
table = rt;
sc = n - (n >>> 2); // 扩容阈值 = 0.75n
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
java 线程安全的map在链表过长时转为红黑树:
• 链表长度≥8 且 数组长度≥64 → 转树
• 树节点≤6 → 退化为链表
• 扩容时优先迁移树节点
扩容时,原桶位置放置ForwardingNode(hash=MOVED=-1):
• 新线程访问时,自动参与迁移
• 旧节点未迁移完时,读操作走旧链表
• 迁移完成后,读写走新链表
// ForwardingNode核心定义
static final class ForwardingNode extends Node {
final Node[] nextTable;
ForwardingNode(Node[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
// find方法:在新表中递归查找
Node find(int h, Object k) {
// 在nextTable中查找
}
}
此设计实现:
• 读写无锁化迁移
• 保证扩容期间数据可见性
• 避免扩容期间阻塞写操作
错误做法:
synchronized(map) { map.put(key, map.get(key)+1); }
高并发下锁竞争剧烈,性能骤降
正确做法:
map.compute(key, (k, v) -> v == null ? 1 : v+1);
map.merge(key, 1, Integer::sum);
| 方案 | 耗时(ms) | 吞吐量(万次/秒) |
|---|---|---|
| synchronized+get/put | 428 | 23.4 |
| compute | 182 | 55.0 |
| merge | 165 | 60.6 |
推荐:map.computeIfAbsent(key, k -> expensiveLoad());
优势:
• 避免重复加载(单次加载)
• 无额外同步开销
• 支持并发加载(不同key)
java 线程安全的map迭代器为弱一致性:
• 不抛ConcurrentModificationException
• 反映“部分”更新(可能看到旧值+新值)
若需强一致性:
List
for(V v : snapshot) { ... }
size()与isEmpty()size()在JDK 1.8中为近似值:
• 基于baseCount + CounterCell累加
• 高并发下可能有±N误差(N=活跃计数器数)
若需精确计数:
LongAdder adder = new LongAdder();
map.compute(key, (k,v) -> { adder.increment(); return newValue; });
ConcurrentHashMap不允许null键值?A:null作为占位符会与“未找到”混淆,破坏线程安全语义:
• get(key)返回null → 是键不存在?还是值为null?
• put(key, null)可能被误判为删除操作
早期Hashtable也禁止null,ConcurrentHashMap延续此设计以简化实现
ConcurrentHashMap的get为何不加锁?A:依赖volatile保证可见性:
• Node的val字段为volatile
• CAS操作确保原子更新
• 链表结构变更时,通过内存屏障保证可见性
static class Node implements Map.Entry {
final int hash;
final K key;
volatile V val;
volatile Node next;
...
}
A:仅在以下情况退化:
• 扩容迁移时,树节点≤6 → 转链表
• 删除操作后树节点≤6 且 数组长度<64 → 不退化(优先扩容)
• 删除操作后树节点≤6 且 数组≥64 → 退化为链表
A:典型场景:本地缓存+分布式锁
if (map.containsKey(key)) return map.get(key);
else synchronized(lock) {
if (map.containsKey(key)) return map.get(key);
else { map.put(key, load()); return map.get(key); }
}
但更推荐:map.computeIfAbsent(key, k -> load());(单机场景)