ConcurrentHashMap
ConcurrentHashMap 是线程安全的 HashMap 实现，是高并发场景下的首选 Map 实现。理解其实现原理，特别是 JDK 7 和 JDK 8 的巨大差异，是面试的高频考点。
一、为什么需要 ConcurrentHashMap
1.1 HashMap 的问题
HashMap 不是线程安全的，在并发环境下会出现问题：
// 问题1：并发扩容导致死循环（JDK 7 头插法）
// 问题2：数据丢失（并发 put）
// 问题3：数据不一致
// 多线程扩容时可能形成环形链表
// 导致 get 操作死循环1.2 Hashtable 的问题
Hashtable 是线程安全的，但性能差：
// Hashtable 所有方法都加 synchronized
public synchronized V put(K key, V value) { }
public synchronized V get(Object key) { }
public synchronized V remove(Object key) { }
// 问题：锁粒度太大，整个表一把锁，并发度极低1.3 ConcurrentHashMap 的优势
| 对比项 | HashMap | Hashtable | ConcurrentHashMap |
|---|---|---|---|
| 线程安全 | ❌ | ✅ | ✅ |
| 锁粒度 | 无 | 整表 | 分段/节点 |
| 并发度 | 高（不安全） | 低 | 高 |
| 性能 | 最高 | 最低 | 高 |
| 允许 null | ✅ | ❌ | ❌ |
二、JDK 7 实现：分段锁
2.1 数据结构
JDK 7 采用**分段锁（Segment）**机制，每个 Segment 是一个小的 HashMap。
┌─────────────────────────────────────────────────────────────┐
│ ConcurrentHashMap (JDK 7) │
├─────────────────────────────────────────────────────────────┤
│ │
│ Segment[] segments │
│ ┌─────────┬─────────┬─────────┬─────────┬─────────┐ │
│ │Segment 0│Segment 1│Segment 2│Segment 3│ ... │ │
│ └────┬────┴────┬────┴────┬────┴────┬────┴─────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │Hash │ │Hash │ │Hash │ │Hash │ 每个 Segment 是 │
│ │Entry│ │Entry│ │Entry│ │Entry│ 一个 HashMap │
│ │ [] │ │ [] │ │ [] │ │ [] │ │
│ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ 链表 链表 链表 链表 │
│ │
│ 每个 Segment 一把锁，默认 16 个 Segment，并发度 16 │
└─────────────────────────────────────────────────────────────┘2.2 核心参数
public class ConcurrentHashMap<K, V> {
// 默认初始容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 默认并发级别（Segment 数量）
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// Segment 数组
final Segment<K,V>[] segments;
// Segment 内部类
static final class Segment<K,V> extends ReentrantLock {
transient volatile HashEntry<K,V>[] table; // 每个 Segment 维护一个链表数组
transient int count; // 元素个数
transient int modCount; // 修改次数
transient int threshold; // 扩容阈值
final float loadFactor; // 负载因子
}
}2.3 put 操作
public V put(K key, V value) {
if (value == null)
throw new NullPointerException();
int hash = hash(key);
return segmentFor(hash).put(key, hash, value, false);
}
// 定位 Segment
final Segment<K,V> segmentFor(int hash) {
return segments[(hash >>> segmentShift) & segmentMask];
}
// Segment.put
V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 1. 尝试获取锁，失败则自旋等待
lock();
try {
int c = count;
if (c++ > threshold) // 检查是否需要扩容
rehash();
HashEntry<K,V>[] tab = table;
int index = hash & (tab.length - 1);
HashEntry<K,V> first = tab[index];
// 2. 遍历链表查找
for (HashEntry<K,V> e = first; e != null; e = e.next) {
if (e.hash == hash && key.equals(e.key)) {
V oldValue = e.value;
if (!onlyIfAbsent)
e.value = value;
return oldValue;
}
}
// 3. 头插法插入新节点
HashEntry<K,V> newEntry = new HashEntry<K,V>(key, hash, first, value);
tab[index] = newEntry;
count = c;
return null;
} finally {
unlock();
}
}2.4 get 操作（无锁）
public V get(Object key) {
int hash = hash(key);
return segmentFor(hash).get(key, hash);
}
V get(Object key, int hash) {
// 不加锁，使用 volatile 保证可见性
HashEntry<K,V>[] tab = table;
HashEntry<K,V> e = tab[hash & (tab.length - 1)];
while (e != null) {
if (e.hash == hash && key.equals(e.key))
return e.value;
e = e.next;
}
return null;
}三、JDK 8 实现：CAS + synchronized
3.1 数据结构
JDK 8 抛弃了 Segment，采用数组 + 链表 + 红黑树，锁粒度细化到每个节点。
┌─────────────────────────────────────────────────────────────┐
│ ConcurrentHashMap (JDK 8) │
├─────────────────────────────────────────────────────────────┤
│ │
│ Node[] table │
│ ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ │
│ │ null│ Node│ null│ Node│ null│ Tree│ null│ Node│ │
│ └─────┴──┬──┴─────┴──┬──┴─────┴──┬──┴─────┴──┬──┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ 链表 链表 红黑树 链表 │
│ │
│ 锁粒度：单个 Node 节点（CAS 或 synchronized） │
│ │
└─────────────────────────────────────────────────────────────┘3.2 核心参数
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
// 默认初始容量
private static final int DEFAULT_CAPACITY = 16;
// 最大容量
private static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子
private static final float LOAD_FACTOR = 0.75f;
// 链表转红黑树阈值
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转链表阈值
static final int UNTREEIFY_THRESHOLD = 6;
// 扩容时的最小步长
private static final int MIN_TRANSFER_STRIDE = 16;
// 扩容时生成 stamp
private static int RESIZE_STAMP_BITS = 16;
// sizeCtl：控制标识符
// -1：正在初始化
// -N：有 N-1 个线程正在扩容
// 正数：扩容阈值
private transient volatile int sizeCtl;
// 扩容时的 nextTable
private transient volatile Node<K,V>[] nextTable;
// 基础计数器
private transient volatile long baseCount;
// 计数器单元格数组（高并发时使用）
private transient volatile CounterCell[] counterCells;
}3.3 put 操作
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 1. key 和 value 都不能为 null
if (key == null || value == null) throw new NullPointerException();
// 2. 计算 hash
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 3. 表为空则初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 4. 位置为空，CAS 插入
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break;
}
// 5. 正在扩容，帮助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 6. 正常插入
else {
V oldVal = null;
synchronized (f) { // 只锁当前节点
if (tabAt(tab, i) == f) {
// 链表
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key, value, null);
break;
}
}
}
// 红黑树
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
// 7. 链表转红黑树
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 8. 更新计数，检查扩容
addCount(1L, binCount);
return null;
}3.4 get 操作（无锁）
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 头节点匹配
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// hash < 0：红黑树或 ForwardingNode
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
// 遍历链表
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}3.5 多线程扩容
JDK 8 的 ConcurrentHashMap 支持多线程协同扩容：
┌─────────────────────────────────────────────────────────────┐
│ 多线程扩容过程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 扩容前：Thread1 触发扩容 │
│ │
│ ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ │
│ │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │10 │11 │12 │13 │ │
│ └─┬─┴───┴─┬─┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘ │
│ │ │ │
│ ▼ ▼ │
│ Thread1 Thread2（帮助扩容） │
│ │
│ 每个线程负责一段区间（stride），协同完成扩容 │
│ 通过 transferIndex 分配任务 │
│ │
│ 已迁移的节点设置为 ForwardingNode（hash = MOVED） │
│ 其他线程遇到 ForwardingNode 会帮助扩容 │
│ │
└─────────────────────────────────────────────────────────────┘四、JDK 7 vs JDK 8 对比
| 对比项 | JDK 7 | JDK 8 |
|---|---|---|
| 数据结构 | Segment + HashEntry 数组 + 链表 | Node 数组 + 链表 + 红黑树 |
| 锁机制 | Segment 分段锁（ReentrantLock） | CAS + synchronized |
| 锁粒度 | Segment 级别（默认 16） | Node 节点级别 |
| 并发度 | 受 Segment 数量限制 | 更高（Node 级别） |
| 扩容 | 单线程扩容 | 多线程协同扩容 |
| 内存占用 | 较高（多个 Segment） | 较低 |
| 查询效率 | O(1) | O(1) 或 O(log n)（红黑树） |
五、重要方法
5.1 spread（哈希计算）
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
// HASH_BITS = 0x7fffffff（最高位为 0）
// 保证 hash 为正数，负数有特殊含义
// MOVED = -1：正在扩容
// TREEBIN = -2：红黑树根节点
}5.2 size() 方法
// JDK 8 使用 LongAdder 思想
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}六、常见面试题
Q1: ConcurrentHashMap 如何保证线程安全？
A:
- JDK 7：Segment 分段锁，每个 Segment 继承 ReentrantLock
- JDK 8：CAS + synchronized，锁粒度更细
Q2: JDK 7 和 JDK 8 的 ConcurrentHashMap 有什么区别？
A:
| 对比项 | JDK 7 | JDK 8 |
|---|---|---|
| 数据结构 | 分段锁 | 数组+链表+红黑树 |
| 锁粒度 | Segment | Node |
| 锁类型 | ReentrantLock | synchronized + CAS |
| 并发度 | 固定（Segment 数） | 更高 |
Q3: ConcurrentHashMap 为什么不允许 null 键/值？
A:
- 二义性问题：
get(key)返回 null 时，无法区分是 key 不存在还是 value 为 null - 多线程环境下无法用
containsKey判断
// 如果允许 null
if (map.containsKey(key)) {
return map.get(key); // 可能是 null
} else {
return null;
}
// 在多线程中，这两步操作之间 map 可能被修改Q4: ConcurrentHashMap 的扩容过程？
A:
- JDK 7：单线程扩容，持有 Segment 锁
- JDK 8：多线程协同扩容
- 每个线程负责一段区间
- 已迁移节点设为 ForwardingNode
- 其他线程遇到会帮助扩容
Q5: ConcurrentHashMap 的 get 为什么不需要加锁？
A:
- Node 的 val 和 next 都是 volatile 的，保证可见性
- 数组用 volatile 读取（tabAt 使用 Unsafe.getObjectVolatile）
- 即使在扩容过程中，ForwardingNode 也能正确转发请求
Q6: ConcurrentHashMap 能完全替代 Hashtable 吗？
A:
- 大部分场景可以
- 但 Hashtable 的迭代是强一致性的
- ConcurrentHashMap 的迭代是弱一致性的（可能不反映最新修改）
七、总结
| 特性 | JDK 7 | JDK 8 |
|---|---|---|
| 数据结构 | Segment + HashEntry | Node + 链表 + 红黑树 |
| 锁机制 | 分段锁（ReentrantLock） | CAS + synchronized |
| 锁粒度 | Segment（粗） | Node（细） |
| get 操作 | 无锁 | 无锁 |
| put 操作 | 锁 Segment | CAS 或 锁 Node |
| 扩容 | 单线程 | 多线程协同 |
| size() | 累加各 Segment | LongAdder 思想 |
一句话总结：JDK 8 的 ConcurrentHashMap 用更细粒度的锁和 CAS 实现了更高的并发度。
最后更新：2026年3月2日