JDK 8 ConcurrentHashMap 详解及详细源码展示
JDK 8 的 ConcurrentHashMap 是 Java 并发包中的核心实现，基于 哈希表 + 链表 + 红黑树 的复合结构，结合 CAS（Compare-And-Swap） 和 synchronized 关键字，实现了高并发的线程安全操作。本文结合源码剖析其设计哲学、核心实现及性能优化技术，并添加关键代码步骤注释。
一、核心设计目标：高并发线程安全
1.1 并发控制策略
- 分段锁优化：JDK 7 中通过分段锁（Segment）实现，JDK 8 改为
synchronized+ CAS，减少锁粒度。 - 无锁化读操作：读操作无需加锁，通过
volatile保证可见性。 - 锁细化：仅锁住链表头节点或红黑树根节点，而非整个哈希桶。
1.2 动态扩容
- 并发扩容：支持多线程参与扩容，减少扩容对性能的影响。
- 容量翻倍：扩容后容量为原来的 2 倍（
newCap = oldCap << 1）。
二、源码核心类结构
// java.util.concurrent.ConcurrentHashMap.java
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
// 默认初始容量（必须是 2 的幂）
static final int DEFAULT_CAPACITY = 16;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
// 最小树化容量
static final int MIN_TREEIFY_CAPACITY = 64;
// 哈希桶数组
private transient volatile Node<K,V>[] table;
// 扩容时的临时数组
private transient volatile Node<K,V>[] nextTable;
// 元素数量
private transient volatile int sizeCtl;
// 哈希桶节点（链表节点）
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
}
// 红黑树节点
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent;
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev;
boolean red;
}
// 扩容时的转发节点
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] nextTable) {
super(MOVED, null, null);
this.nextTable = nextTable;
}
}
}
三、核心方法源码解析（含关键代码注释）
3.1 put 方法
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 1. 参数校验（不允许 null 键值）
if (key == null || value == null) throw new NullPointerException();
// 2. 哈希计算（高位参与运算，减少哈希冲突）
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);
else {
V oldVal = null;
// 6. 同步锁控制（仅锁住链表头节点）
synchronized (f) {
if (tabAt(tab, i) == f) {
// 7. 处理链表节点
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f; ; ++binCount) {
K ek;
// 8. 键已存在，替换值
if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
// 9. 键不存在，追加到链表尾部
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key, value, null);
break;
}
}
}
// 10. 处理红黑树节点
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;
}
}
}
}
// 11. 链表转红黑树
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 12. 更新元素数量
addCount(1L, binCount);
return null;
}
3.2 get 方法
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// 1. 哈希计算
int h = spread(key.hashCode());
// 2. 遍历哈希桶数组
if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
// 3. 检查头节点
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// 4. 处理红黑树节点
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
// 5. 遍历链表
while ((e = e.next) != null) {
if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
3.3 resize 方法
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// 1. 计算每个线程处理的桶数量
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
// 2. 初始化新数组
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) {
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;
}
int nextn = nextTab.length;
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false;
// 3. 多线程协同扩容
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
else if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// 4. 处理边界条件
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n;
}
}
// 5. 处理空桶（直接转发）
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 6. 处理已转发节点
else if ((fh = f.hash) == MOVED)
advance = true;
else {
// 7. 同步锁控制（仅锁住链表头节点）
synchronized (f) {
if (tabAt(tab, i) == f) {
// 8. 拆分链表到新数组
Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash;
K pk = p.key;
V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
// 9. 拆分红黑树到新数组
else if (f instanceof TreeBin) {
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : (hc != 0 ? new TreeBin<K,V>(lo) : t);
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : (lc != 0 ? new TreeBin<K,V>(hi) : t);
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
四、关键优化技术
4.1 并发控制优化
- CAS 操作：用于无锁化的初始化和空桶插入。
- synchronized 锁：仅锁住链表头节点或红黑树根节点，减少锁竞争。
4.2 动态扩容优化
- 多线程协同：通过
transfer方法支持多线程参与扩容。 - 容量计算：扩容后容量为原来的 2 倍，减少频繁扩容开销。
4.3 内存局部性优化
- 连续内存：元素在内存中连续存储，提升缓存命中率。
- 数组复制：通过
System.arraycopy优化数组复制性能。
五、典型应用场景
5.1 基础操作
// 创建 ConcurrentHashMap
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
// 添加元素
map.put("A", "1");
map.put("B", "2");
// 读取元素
String value = map.get("A"); // "1"
// 删除元素
map.remove("B");
5.2 批量操作
// 批量添加
map.putAll(Collections.singletonMap("C", "3"));
// 批量删除
map.keySet().removeIf(key -> key.equals("A"));
// 遍历操作
map.forEach((k, v) -> System.out.println(k + "=" + v));
5.3 并发安全操作
// 原子更新
map.compute("A", (k, v) -> (v == null) ? "1" : v + "1");
// 条件更新
map.merge("B", "2", (oldVal, newVal) -> oldVal + newVal);
六、总结
JDK 8 的 ConcurrentHashMap 通过哈希表、链表、红黑树的复合结构，结合 CAS 和 synchronized，实现了高并发的线程安全操作。其源码实现深刻体现了并发编程的精髓：
- 无锁化与锁细化：通过 CAS 和
synchronized减少锁竞争。 - 动态扩容：支持多线程协同扩容，减少性能损耗。
- 内存局部性：连续内存布局提升缓存命中率。
实际开发中，建议优先使用 ConcurrentHashMap，但在低并发场景下可考虑 HashMap 或 Hashtable。深入理解其源码，有助于设计高性能的并发应用程序。
扫一扫
1747
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
