JDK1.8的ConcurrentHashMap的put方法源码

一、JDK1.8的ConcurrentHashMap的put方法源码

ConcurrentHashMap 是 Java 并发包（java.util.concurrent）中的一个高性能线程安全哈希表实现。在 JDK 1.8 中，ConcurrentHashMap 的 put 方法是其核心方法之一，负责插入键值对并保证线程安全。

以下是 put 方法的详细源码解析，结合并发机制和设计思想

1、put 方法入口

• 参数：

  • key：键。

  • value：值。

  • onlyIfAbsent：如果为 true，则仅在键不存在时插入

• 返回值：如果键已存在，返回旧值；否则返回 null

2、putVal 方法解析

putVal 是 put 方法的核心实现，以下是其源码逐段解析：

(1) 参数校验

• 设计意图：ConcurrentHashMap 不允许 null 键或值，因为在并发场景中，null 可能导致歧义（例如，无法区分“键不存在”和“键对应的值为 null”）

(2) 哈希计算

• spread() 方法：对原始哈希码进行二次处理，确保哈希值均匀分布

• 作用：

  • 通过异或高位和低位，减少哈希冲突

  • 通过 & HASH_BITS 确保哈希值为正数（负哈希用于标记特殊节点，如扩容时的 ForwardingNode）

(3) 自旋插入逻辑

• 关键点：

  • CAS 无锁插入：若桶为空，直接通过 casTabAt 原子操作插入新节点，避免加锁

  • 协助扩容：若发现桶已被标记为 MOVED（ForwardingNode），当前线程会协助迁移数据，提升扩容效率

(4) initTable() 初始化哈希表

initTable() 是 ConcurrentHashMap 在 JDK 1.8 中用于初始化哈希表的核心方法。当 ConcurrentHashMap 第一次插入数据时，如果哈希表尚未初始化，

会调用 initTable() 方法创建并初始化哈希表。以下是 initTable() 方法的详细源码解析。

a、方法签名

b、方法解析

i、检查表是否已初始化

• 条件：如果 table 为 null 或长度为 0，表示哈希表尚未初始化。

• 作用：确保哈希表未初始化时才执行初始化逻辑。

ii、检查是否有其他线程正在初始化

• sizeCtl 的作用：

  • sizeCtl 是 ConcurrentHashMap 的控制状态变量，用于控制初始化和扩容

  • 当 sizeCtl < 0 时，表示有其他线程正在初始化或扩容

• Thread.yield()：让出 CPU，等待其他线程完成初始化

iii、尝试 CAS 设置 sizeCtl 为 -1

• CAS 操作：通过 CAS 将 sizeCtl 设置为 -1，表示当前线程正在初始化

• 作用：确保只有一个线程执行初始化逻辑

iV、双重检查

• 作用：防止其他线程已经完成初始化

iiV、计算初始容量

• sc 的作用：

  • 如果 sc > 0，表示用户指定了初始容量

  • 否则，使用默认容量 DEFAULT_CAPACITY（默认值为 16）

• 作用：确定哈希表的初始容量

iiiV、创建哈希表

• 作用：创建长度为 n 的 Node 数组，并将其赋值给 table

iVi、计算扩容阈值

• 计算逻辑：

  • n >>> 2 表示 n / 4

  • n - (n >>> 2) 表示 n * 0.75

• 作用：设置扩容阈值（sizeCtl），当元素数量超过阈值时触发扩容

iVii、 恢复 sizeCtl 的值

• 作用：初始化完成后，恢复 sizeCtl 的值，表示初始化完成

c、示例场景

假设 ConcurrentHashMap 第一次插入数据：

1、线程 A 检查 table，发现尚未初始化

2、线程 A 通过 CAS 将 sizeCtl 设置为 -1，表示正在初始化

3、线程 A 创建哈希表，并设置扩容阈值

4、线程 A 恢复 sizeCtl 的值，表示初始化完成

5、其他线程在初始化期间会调用 Thread.yield()，等待初始化完成

(5) helpTransfer(tab, f)方法源码

helpTransfer(tab, f) 是 ConcurrentHashMap 在 JDK 1.8 中用于协助扩容的核心方法之一。当线程在插入数据时发现当前桶正在迁移（即桶的头节点是 ForwardingNode），会调用 helpTransfer 方法协助其他线程完成数据迁移。以下是 helpTransfer 方法的详细源码解析：

a、方法签名

b、方法解析

i、 检查扩容状态

• 条件：

  • 1、当前表 tab 不为空。

  • 2、当前桶的头节点 f 是 ForwardingNode（表示桶正在迁移）。

  • 3、ForwardingNode 的 nextTable 不为空（表示扩容正在进行）。

• 作用：确认当前表正在扩容，且需要协助。

ii、 计算扩容戳

• resizeStamp() 方法：生成一个扩容戳，用于标识当前扩容的状态。

• 作用：

  • 1、Integer.numberOfLeadingZeros(n)：计算表长度的前导零个数

  • 2、(1 << (RESIZE_STAMP_BITS - 1))：生成一个标志位

  • 3、最终结果是一个唯一的扩容戳，用于标识当前扩容

iii、 检查扩容是否仍在进行

• 条件：

  • 1、nextTab 仍然是 nextTable（扩容目标表未改变）。

  • 2、table 仍然是 tab（当前表未改变）。

  • 3、sizeCtl 为负数（表示扩容仍在进行）。

• 作用：确保当前扩容状态未发生变化

vi、判断是否需要协助

• 条件：

  • 1、(sc >>> RESIZE_STAMP_SHIFT) != rs：扩容戳不匹配。

  • 2、sc == rs + 1：扩容已完成。

  • 3、sc == rs + MAX_RESIZERS：扩容线程数已达到最大值。

  • 4、transferIndex <= 0：所有桶已分配完毕。

• 作用：如果满足任一条件，则无需协助，直接退出。

vii、尝试增加扩容线程数

• CAS 操作：通过 CAS 将 sizeCtl 的值加 1，表示当前线程加入扩容

• transfer() 方法：调用 transfer 方法协助迁移数据

viii、返回新表

• 作用：返回扩容目标表 nextTab，供后续操作使用

c、transfer 方法的作用

transfer 方法是 ConcurrentHashMap 扩容的核心逻辑，负责将数据从旧表迁移到新表。以下是 transfer 方法的主要步骤：

• 1、计算迁移范围：

  • 每个线程负责迁移一部分桶

  • 通过 transferIndex 分配迁移任务

• 2、迁移数据：

  • 遍历旧表中的每个桶，将节点迁移到新表

  • 如果桶是链表，则拆分为高低链表；如果是红黑树，则拆分为高低树

• 3、标记迁移完成：

  • 迁移完成后，将桶标记为 ForwardingNode

d、示例场景

假设 ConcurrentHashMap 正在扩容，线程 A 在插入数据时发现当前桶正在迁移，调用 helpTransfer 方法协助迁移：

1、线程 A 检查扩容状态，确认需要协助

2、线程 A 通过 CAS 增加扩容线程数，并调用 transfer 方法迁移数据

3、线程 A 完成迁移任务后，继续执行插入操作

(6) transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) 解析

transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) 是 ConcurrentHashMap 在 JDK 1.8 中用于扩容和数据迁移的核心方法。当哈希表中的元素数量超过阈值时，ConcurrentHashMap 会触发扩容，

并通过 transfer 方法将数据从旧表迁移到新表。transfer 方法支持多线程协作迁移数据，以提高扩容效率。

以下是 transfer 方法的详细源码解析

a、方法签名

    private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        // 1. 计算每个线程负责的迁移范围（stride）
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // 最小迁移范围
        // 2. 初始化新表（nextTab）
        if (nextTab == null) {
            try {
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; // 新表容量为旧表的两倍
                nextTab = nt;
            } catch (Throwable ex) {
                sizeCtl = Integer.MAX_VALUE; // 扩容失败，恢复 sizeCtl
                return;
            }
            nextTable = nextTab;
            transferIndex = n; // 初始化迁移索引
        }
        int nextn = nextTab.length;
        // 3. 创建 ForwardingNode 节点，用于标记迁移中的桶
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        boolean advance = true;
        boolean finishing = false; // 是否完成迁移
        // 4. 自旋迁移数据
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            // 4.1 分配迁移任务
            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.2 检查迁移是否完成
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                if (finishing) {
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1); // 更新 sizeCtl
                    return;
                }
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    i = n; // 重新检查所有桶
                }
            }
            // 4.3 迁移空桶
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            // 4.4 迁移已处理的桶
            else if ((fh = f.hash) == MOVED)
                advance = true; // 跳过已迁移的桶
            // 4.5 迁移非空桶
            else {
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        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;
                        }
                        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;
                        }
                    }
                }
            }
        }
    }

b、方法解析

i、计算迁移范围

• stride：每个线程负责迁移的桶数量

• NCPU：CPU 核心数

• MIN_TRANSFER_STRIDE：最小迁移范围（默认 16）

• 作用：根据 CPU 核心数动态分配迁移任务

ii、初始化新表

• 作用：创建新表，容量为旧表的两倍

iii、创建 ForwardingNode

• ForwardingNode：用于标记迁移中的桶，其他线程遇到时会协助迁移

Vi、自旋迁移数据

• 关键点：

  • 分配迁移任务：通过 CAS 更新 transferIndex，分配迁移范围

  • 迁移空桶：将空桶标记为 ForwardingNode

  • 迁移非空桶：加锁迁移链表或红黑树

Vii、迁移链表

• 作用：将链表拆分为高低链表，分别迁移到新表

Viii、迁移红黑树

• 作用：将红黑树拆分为高低树，分别迁移到新表

c、总结

transfer 方法：用于扩容和数据迁移，支持多线程协作。

• 核心机制：

  • 通过 CAS 分配迁移任务。

  • 使用 ForwardingNode 标记迁移中的桶。

  • 渐进式迁移，不影响读操作。

• 适用场景：ConcurrentHashMap 的动态扩容

(7) 处理哈希冲突（加锁逻辑）

• 锁策略：

  • 细粒度锁：仅锁住当前冲突的桶（头节点），其他桶仍可并发访问。

  • 双重检查：加锁后再次检查桶是否被修改，避免锁期间其他线程已修改结构

• 链表与红黑树：

  • 链表插入采用尾插法（JDK 1.8 的改进，避免循环链表问题）。

  • 当链表长度超过 TREEIFY_THRESHOLD（默认8），会转换为红黑树。

(8) 链表转红黑树

• 触发条件：单个桶的链表长度 ≥ TREEIFY_THRESHOLD（默认8）。

• 实际转换条件：

  • 哈希表长度 ≥ MIN_TREEIFY_CAPACITY（默认64），否则优先扩容。

(9) 更新元素计数

• addCount() 方法：使用类似 LongAdder 的分段计数机制，减少 CAS 竞争。

• 设计目的：通过分散计数到多个 CounterCell，避免所有线程竞争同一变量

二、核心并发设计总结

1、无锁读：读操作直接访问 volatile 变量，无需同步。

2、CAS 写：桶为空时通过 CAS 插入，避免锁竞争。

3、细粒度锁：哈希冲突时仅锁住当前桶，锁粒度极小。

4、分段计数：使用 CounterCell 分散计数，减少 CAS 冲突。

5、协作扩容：多线程协同迁移数据，提升扩容效率。