JUC：ConcurrentHashMap分段锁演进史：从JDK7到JDK8的革新之路
Contents
ConcurrentHashMap是Java并发编程中至关重要的线程安全容器，其设计演进体现了对高并发场景下性能与安全的极致追求。本文将从分段锁的起源、JDK7的实现缺陷，到JDK8的架构革新，全面解析其演进历程。
一、JDK7分段锁设计：以空间换并发
1. 核心架构
JDK7的ConcurrentHashMap采用**分段锁（Segment）**机制，将整个哈希表划分为多个独立段（默认16段），每个段继承自ReentrantLock，形成一个独立的哈希表（数组+链表）。这种设计允许多线程同时操作不同段，实现并发读写。
2. 分段锁的优劣分析
优势：
- 降低锁粒度：不同段的操作无需竞争同一锁，提升并发度。
- 兼容性：相比
Hashtable的全表锁，性能显著提升。
缺陷：
- 内存浪费：每个段需维护独立锁和数据结构，内存碎片化严重。
- 锁竞争未根治：同一段内操作仍需竞争锁，高并发下性能瓶颈明显。
- 扩容效率低：段的大小固定，扩容需整体迁移，无法动态调整。
3. 典型应用场景
适用于段间操作互不冲突的场景，但对段内高并发写入仍存在瓶颈。
二、JDK8架构革新：CAS与细粒度锁的融合
1. 核心改进
JDK8彻底摒弃分段锁，采用Node数组+链表/红黑树结构，结合CAS（无锁化操作）与synchronized（锁单个桶头节点）实现线程安全。
2. 关键技术突破
- 锁粒度极致细化：仅对哈希桶的头节点加锁，冲突概率大幅降低。
- CAS无锁化插入：若桶为空，直接通过
CAS插入节点，避免锁竞争。 - 红黑树优化查询：链表长度超8时转为红黑树，查询复杂度从O(n)降至O(logn)。
- 并发扩容机制：多线程协同迁移数据，扩容期间仍支持读写操作。
3. 性能提升关键点
- 内存效率：取消Segment结构，减少冗余内存占用。
- JVM优化支持：
synchronized由JVM实现锁优化（如锁粗化、自旋），性能优于ReentrantLock。 - 动态扩容策略：根据负载因子和树化阈值智能调整结构，避免无效锁竞争。
三、JDK7 vs JDK8：关键对比与演进意义
| 维度 | JDK7（分段锁） | JDK8（CAS+synchronized） |
|---|---|---|
| 锁粒度 | 段级锁（默认16段） | 桶级锁（锁单个Node） |
| 数据结构 | Segment数组+链表 | Node数组+链表/红黑树 |
| 线程安全机制 | ReentrantLock分段锁 | CAS（读） + synchronized（写） |
| 内存占用 | 高（多段独立结构） | 低（结构紧凑） |
| 扩容效率 | 段内独立扩容，迁移效率低 | 多线程协同扩容，迁移效率高 |
| 查询性能 | O(n)（链表遍历） | O(logn)（红黑树优化） |
| 适用场景 | 中低并发，段间操作分散 | 高并发，读写混合场景 |
演进意义：
JDK8通过无锁化设计与极致细粒度锁的结合，解决了分段锁的内存浪费与竞争瓶颈问题，同时利用红黑树和并发扩容机制，显著提升了高并发下的吞吐量与稳定性。
四、实战示例：JDK8的put过程解析
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 1. 计算哈希值，定位桶位置
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 2. 若表未初始化，则CAS初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 3. 若桶为空，直接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; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 4. 若桶非空，synchronized锁头节点
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;
}
}
}
}
if (binCount != 0) {
// 处理链表或红黑树插入
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 5. 统计元素数量并检查扩容
addCount(1L, binCount);
return null;
}
流程亮点：
- 无锁化初始化与插入：通过
CAS减少锁竞争。 - 动态树化：链表超长时转为红黑树，优化查询。
五、总结
JDK7的分段锁设计虽提升了并发度，但受限于内存与锁竞争问题。JDK8通过CAS+synchronized+红黑树的组合，实现了锁粒度的革命性细化与性能飞跃，成为高并发场景下的首选容器。