深度解析 ConcurrentHashMap 1.8：put 与 get 核心流程全解

在 Java 并发编程中，ConcurrentHashMap 是线程安全的高频使用集合 ，相比线程不安全的 HashMap、效率低下的 HashTable（全锁），JDK 1.8 版本的 ConcurrentHashMap 做了底层结构重构 和锁机制优化，成为高并发场景下的首选 Map 实现。

本文将逐行拆解核心原理 ，深度解析 ConcurrentHashMap 1.8 的 put 存值、get 取值完整流程，帮你彻底吃透这个高频面试 + 工作必备的核心组件。

一、前置知识：ConcurrentHashMap 1.8 核心特性

先明确 1.8 版本的关键改动，这是理解流程的基础：

底层结构 ：从 1.7 的分段锁 + 数组 + 链表 → 改为 数组 + 链表 + 红黑树；
锁机制 ：放弃分段锁，使用 CAS + synchronized 锁头节点 实现细粒度并发；
并发效率：锁的粒度从「分段」缩小到「数组桶的头节点」，不同桶的操作完全并行，性能大幅提升；
树化阈值：链表长度 ≥8 且数组长度 ≥64 时，链表转为红黑树（查询效率从 O (n) 升为 O (logn)）。

核心常量：

DEFAULT_INITIAL_CAPACITY：默认容量 16
DEFAULT_LOAD_FACTOR：负载因子 0.75
TREEIFY_THRESHOLD：树化阈值 8
UNTREEIFY_THRESHOLD：退化阈值 6

二、ConcurrentHashMap 1.8 put 流程深度解析

put 方法的核心目标：线程安全地将 key-value 存入集合，处理哈希冲突、扩容、树化 。整体流程分为 8 个核心步骤，我们结合源码逻辑逐段解析：

put 方法完整流程

参数校验 ：key 和 value 都不允许为 null（HashMap 允许），直接抛空指针异常；
计算哈希值 ：通过 spread(key.hashCode()) 计算哈希，高位参与运算，减少哈希冲突；
初始化数组 ：如果底层数组 table 为 null 或长度为 0，执行 initTable() 初始化（CAS 控制单线程初始化）；
定位数组桶 ：通过 (n - 1) & hash 计算数组下标，定位目标桶；
桶为空：CAS 直接插入 ：如果目标桶没有元素，无锁使用 CAS 尝试插入新节点，成功则直接结束；
桶不为空：加锁处理冲突 ：
- 对桶的头节点 加 synchronized 锁（细粒度锁，不影响其他桶）；
- 判断桶内是链表还是红黑树 ：
  - 链表：遍历链表，找到相同 key 则覆盖 value，无相同 key 则追加到链表尾部；
  - 红黑树：调用红黑树插入方法，处理节点插入 / 覆盖；
树化判断 ：插入后检查链表长度，达到树化阈值 8 则执行 treeifyBin() 转为红黑树；
扩容检查 ：插入完成后，检查元素数量是否达到扩容阈值（容量 ×0.75），达到则执行 resize() 扩容（并发扩容，多线程协助迁移数据）。

put 流程核心细节

**为什么 key/value 不能为 null？**并发场景下无法区分「未存入」和「存入 null」，会导致并发判断歧义；而 HashMap 是单线程集合，无此问题。
CAS 无锁插入：桶为空时，用 CAS 保证原子性插入，避免加锁开销，提升并发效率；
synchronized 锁的是头节点：只锁当前桶，不同桶的 put 操作可以并行执行，这是 1.8 并发性能远超 1.7 的核心原因；
并发扩容 ：扩容时会生成一个新数组，多线程可以协助迁移数据，避免单线程扩容的性能瓶颈。

put 源码核心片段（简化版）

复制代码

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // 1. key/value 非空校验
    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. 数组未初始化：CAS 初始化
        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;
                            // key 相同：覆盖 value
                            if (e.hash == hash && ((ek = e.key) == key || (key != 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;
}

三、ConcurrentHashMap 1.8 get 流程深度解析

get 方法全程无锁，是 ConcurrentHashMap 高并发读取的核心优势，流程极简且高效。

get 方法完整流程

参数校验：key 为 null 直接抛异常；
计算哈希值 ：和 put 流程一致，通过 spread() 计算哈希；
定位数组桶 ：通过 (n - 1) & hash 找到目标数组下标；
查找目标节点 ：
- 桶头节点：哈希、key 匹配，直接返回 value；
- 链表：遍历链表，找到匹配 key 则返回 value；
- 红黑树：调用红黑树查找方法，返回匹配节点的 value；
未找到：返回 null。

get 流程核心细节

全程无锁 ：为什么不需要加锁还能线程安全？
- 底层数组 table 用 volatile 修饰，保证可见性（一个线程修改，其他线程立即感知）；
- 节点的 val 和 next 也用 volatile 修饰，读取时能获取最新值；
- 读操作不会修改数据，天然线程安全，无需加锁。
效率极高：无锁设计让读取操作几乎无开销，高并发下读取性能接近 HashMap。

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());
    // 1. 数组不为空 && 目标桶存在元素
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 2. 头节点匹配：直接返回
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (key != null && key.equals(ek)))
                return e.val;
        }
        // 3. 红黑树节点：查找
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 4. 链表遍历：查找
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (key != null && key.equals(ek))))
                return e.val;
        }
    }
    // 未找到返回 null
    return null;
}

四、put 与 get 流程核心对比

特性	put 流程	get 流程
线程安全方式	CAS + synchronized 锁头节点	全程无锁（volatile 保证可见性）
性能开销	有锁开销（细粒度，并发度高）	无锁，开销极低
数据修改	会修改集合（插入 / 覆盖 / 扩容 / 树化）	只读，不修改任何数据
失败重试	自旋保证插入成功	无重试，直接返回结果