ConcurrentHashMap 核心源码解析：putVal、get、transfer、helpTransfer
putVal
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 不允许 null 键/值，与 HashMap 不同
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode()); // 扰动函数，混合高低位
int binCount = 0;
for (Node<K,V>[] tab = table;;) { // 自旋，直到插入成功
Node<K,V> f; int n, i, fh; K fk; V fv;
// 1. 懒初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 2. 桶为空：CAS 无锁插入
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
break; // 插入成功，退出循环
}
// 3. 桶正在扩容：协助迁移
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 4. 仅当不存在时的快速路径（避免加锁）
else if (onlyIfAbsent // 检查首节点是否匹配
&& fh == hash
&& ((fk = f.key) == key || (fk != null && key.equals(fk)))
&& (fv = f.val) != null)
return fv;
// 5. 桶非空且非扩容状态：加锁处理
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);
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;
}
}
else if (f instanceof ReservationNode)
throw new IllegalStateException("Recursive update");
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i); // 树化（检查容量）
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount); // 计数 + 扩容检查
return null;
}
解读
-
自旋：整个插入操作在一个无限循环中完成，通过 CAS 或锁来保证最终成功。
-
懒初始化：如果
table未初始化，调用initTable()进行初始化。initTable内部通过sizeCtl的 CAS 控制并发，只有一个线程会初始化，其余自旋等待。 -
空桶插入：通过
tabAt（Unsafe.getObjectVolatile）获取桶首节点，若为null，则尝试casTabAt将新节点放入。这是无锁操作，性能极高。若 CAS 成功则插入完成。 -
协助扩容：如果桶首节点的
hash == MOVED（-1），说明该桶正在扩容迁移，当前线程调用helpTransfer协助完成迁移，然后重试。 -
桶非空且非扩容：这才是真正发生哈希冲突的情况。需要对桶首节点加锁（
synchronized (f)），保证同一个桶内的修改互斥。加锁后再次检查首节点是否变化（双重检查），防止在获取锁前被其他线程修改。-
根据节点类型分别处理链表或红黑树：
- 链表：遍历查找，未找到则在尾部插入新节点，并更新
binCount。 - 红黑树：调用
putTreeVal插入或查找。
- 链表：遍历查找，未找到则在尾部插入新节点，并更新
-
插入完成后，检查是否需要树化（
binCount >= TREEIFY_THRESHOLD）。注意treeifyBin内部还会检查数组长度是否小于 64，若小于则优先扩容而非树化。
-
-
计数与扩容：
addCount增加元素总数，并可能触发扩容。addCount内部采用CounterCell分散计数，减少竞争。
get
get 方法全程无锁，仅依赖 volatile 和 Unsafe 保证可见性。源码如下：
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;
}
// 哈希为负的特殊节点（ForwardingNode、TreeBin、ReservationNode）
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;
}
解析
-
获取最新数组：通过
volatile读table，再通过tabAt（Unsafe.getObjectVolatile）读桶首节点，保证看到其他线程的最新修改。 -
快速命中：先检查首节点是否匹配，若是则直接返回值，这是最常见的路径。
-
特殊节点处理：如果是正在扩容的
ForwardingNode，调用其find方法去新表中查找。 -
链表遍历：如果首节点是普通节点且未命中，则遍历链表查找。
transfer 方法
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 {
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // OOM
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;
// 3.1 获取下一个要处理的桶索引（通过 CAS 竞争 transferIndex）
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
else if (U.compareAndSetInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// 3.2 检查是否全部迁移完成
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) { // 最后一个线程负责提交新表
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1); // 新阈值 = 新容量 * 0.75
return;
}
if (U.compareAndSetInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return; // 不是最后一个线程，直接退出
finishing = advance = true; // 最后一个线程，需要再扫描一遍
i = n;
}
}
// 3.3 处理单个桶
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd); // 空桶直接置为 fwd
else if ((fh = f.hash) == MOVED)
advance = true; // 已被其他线程处理
else {
synchronized (f) { // 加锁迁移
if (tabAt(tab, i) == f) {
// 链表迁移
if (fh >= 0) {
// 将链表拆分为低位链和高位链（通过 hash & n）
// 使用 lastRun 优化，减少节点复制
// ... 代码省略
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
// 红黑树迁移
else if (f instanceof TreeBin) {
// 类似链表，拆分为两条链，并根据节点数决定是否树化
// ...
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
关键设计
- 多线程协作：通过
transferIndex和 CAS 分配任务区间，每个线程处理一段连续的桶（步长stride），从高索引向低索引推进，充分利用多核。 - ForwardingNode：迁移完成的桶被替换为
ForwardingNode，后续读操作会转发到新表；写操作遇到它会协助扩容（helpTransfer）。 - 桶级别锁：迁移单个桶时，对桶首节点加锁，确保同一桶不会被多个线程同时迁移，也不会被插入操作干扰。
- lastRun 优化：遍历链表时，找出最后一段哈希位相同的子链直接复用，减少节点创建。
- 树退化：红黑树迁移后，如果一条链节点数 ≤ 6，退化为链表，避免维护红黑树的开销。
- 收尾检查：最后一个退出的线程会再次扫描所有桶，确保没有遗漏（
finishing路径），然后提交新表。
helpTransfer
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 1. 检查参数有效性：tab不为空，f是ForwardingNode，且其nextTable（新表）不为空
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 2. 根据当前旧表长度生成扩容戳，并左移16位（RESIZE_STAMP_SHIFT=16）
int rs = resizeStamp(tab.length) << RESIZE_STAMP_SHIFT;
// 3. 循环判断，确保当前仍在同一轮扩容中（nextTab和table未变）
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) { // sizeCtl<0表示正在扩容
// 4. 判断扩容是否已接近尾声或当前线程无法再参与
if (sc == rs + MAX_RESIZERS || sc == rs + 1 ||
transferIndex <= 0)
break;
// 5. 尝试用CAS将sizeCtl加1（表示增加一个参与扩容的线程）
if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1)) {
// 成功则调用transfer方法真正执行迁移工作
transfer(tab, nextTab);
break;
}
}
// 6. 返回新表引用（或当前表，视情况而定）
return nextTab;
}
return table;
}
HashMap
putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 1. 懒初始化：如果 table 为空，则调用 resize() 创建数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 2. 计算索引，如果桶为空，直接插入新节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 3. 桶非空，发生哈希冲突
Node<K,V> e; K k;
// 3.1 检查头节点是否匹配
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 3.2 如果是树节点，调用红黑树的插入方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 3.3 遍历链表
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 在链表尾部插入新节点
p.next = newNode(hash, key, value, null);
// 如果链表长度达到树化阈值（8），尝试树化
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break; // 找到匹配节点
p = e;
}
}
// 4. 如果找到了已存在的键（e != null），根据 onlyIfAbsent 决定是否更新值
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // LinkedHashMap 回调
return oldValue;
}
}
// 5. 插入新节点后的收尾工作
++modCount; // 修改次数加1
if (++size > threshold)
resize(); // 检查是否需要扩容
afterNodeInsertion(evict); // LinkedHashMap 回调
return null;
}
逐段解读
-
懒初始化：如果
table为null或长度为 0，说明还未初始化，调用resize()创建数组。这也是第一次插入元素时数组被创建的时机。 -
空桶直接插入：计算索引后，如果该桶没有节点，则直接创建新节点放入。这是最简单的无冲突情况。
-
桶非空：
-
头节点匹配：先检查头节点是否就是目标键，若是则
e指向头节点。 -
红黑树节点：如果头节点是
TreeNode，说明该桶已树化，调用putTreeVal在树中插入或查找。 -
链表遍历：遍历链表，查找是否存在相同键。
- 如果遍历完链表未找到，则在尾部插入新节点，并检查是否需要树化（链表长度 ≥ 8）。注意
treeifyBin内部会检查数组长度是否 ≥ 64，否则会优先扩容而非树化。 - 如果找到相同键，则跳出循环，
e指向该节点。
- 如果遍历完链表未找到，则在尾部插入新节点，并检查是否需要树化（链表长度 ≥ 8）。注意
-
-
处理已存在的键：如果
e != null，说明键已存在。根据onlyIfAbsent决定是否用新值覆盖旧值。最后返回旧值。 -
插入新键后的操作：
modCount加 1，记录结构修改，用于迭代器的 fail-fast。size加 1，如果超过阈值，调用resize()扩容。- 调用
afterNodeInsertion（空实现，留给LinkedHashMap使用）。
resize 扩容方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 1. 计算新容量和新阈值
if (oldCap > 0) {
// 已经初始化过的情况
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 阈值翻倍
}
else if (oldThr > 0) // 初始容量保存在 threshold 中（指定了 initialCapacity）
newCap = oldThr;
else { // 使用默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 2. 如果新阈值为 0，重新计算
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
// 3. 创建新数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 4. 迁移数据
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null; // 帮助 GC
if (e.next == null)
// 单个节点，直接计算新索引放入
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 树节点，调用 split 方法拆分
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 链表
// 拆分为低位链和高位链
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) { // 低位
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else { // 高位
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead; // 原位
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead; // 原位 + oldCap
}
}
}
}
}
return newTab;
}
解析
-
链表拆分：
- 利用
(e.hash & oldCap) == 0判断节点在扩容后是留在原索引（低位），还是移到原索引 + oldCap（高位）。 - 这个判断利用了容量是 2 的幂的特性：
oldCap对应二进制中唯一为 1 的那一位，e.hash & oldCap即取出这一位，决定在新表中的位置。 - 使用
loHead/loTail和hiHead/hiTail分别收集两条链，并保持原有顺序（JDK 1.8 后采用尾插法，避免死循环）。
- 利用
-
红黑树拆分：调用
split方法，类似地将树拆成两棵或退化为链表，根据节点数决定是否保持树化。
