深入揭秘 ConcurrentHashMap：JDK7 到 JDK8 并发优化的演进之路

引言

本文主要从源码层次探讨 ConcurrentHashMap 的并发控制实现，全文可以浓缩为下面的内容，也可以用来回答问题《ConcurrentHashMap 是如何实现线程安全支持高并发的？》

在 JDK 7 中，ConcurrentHashMap 是使用数组加链表的结构实现的。数组又分为 HashEntry 数组 和 Segement 数组。其中 Segement 数组使用 ReentrantLock 控制并发，HashEntry 就是存放键值对的。JDK 7 中为每一段桶分配一个 segment 分段锁，当需要操作某一个桶中的数据时，需要先获取到对应的分段所

在 JDK 8 中，ConcurrentHashMap 是使用的数组加链表加红黑树实现的。通过 volatile + cas （乐观锁）和 synchronized （悲观锁）实现并发控制的。锁的粒度减少到对桶头加锁，并发度更高。并且链表可以优化为红黑树，查询效率也比 JDK 7 的高；其次 HashMap 扩容的时候，其他线程可以协助扩容

---

1. (JDK 8) ConcurrentHashMap

ConcurrentHashMap 的重要属性和内部类

// 默认为 0
// 当初始化时, 为 -1
// 当扩容时, 为 -(1 + 扩容线程数)
// 当初始化或扩容完成后，为下一次的扩容的阈值大小
private transient volatile int sizeCtl;
// 整个 ConcurrentHashMap 就是一个 Node[]
static class Node<K,V> implements Map.Entry<K,V> {}
// hash 表
transient volatile Node<K,V>[] table;
// 扩容时的新 hash 表
private transient volatile Node<K,V>[] nextTable;
// 扩容时如果某个 bin 迁移完毕, 用 ForwardingNode 作为旧 table bin 的头结点
static final class ForwardingNode<K,V> extends Node<K,V> {}
// 用在 compute 以及 computeIfAbsent 时, 用来占位, 计算完成后替换为普通 Node
static final class ReservationNode<K,V> extends Node<K,V> {}
// 作为 treebin 的头节点, 存储 root 和 first
static final class TreeBin<K,V> extends Node<K,V> {}
// 作为 treebin 的节点, 存储 parent, left, right
static final class TreeNode<K,V> extends Node<K,V> {}

可以发现在 JDK 8 的 ConcurrentHashMap 中，底层数组就是 Node[]，存放的都是 Node 或者它的子类。相对于 HashMap 来说，ConcurrentHashMap 在数组中用 ForwardingNode 和 TreeBin 当哨兵

sizeCtl 的作用

• sizeCtl < 0 且"戳匹配"说明正在扩容：本线程可 帮忙（sc+1）并调用 transfer(tab, nt)
• sizeCtl >= 0 且超过阈值：当前线程成为主扩容者，设置 sizeCtl = (rs<<shift)+2 后进入 transfer
• 扩容完成后，sizeCtl 会被恢复为新阈值

ForwardingNode 的哨兵作用：

1. 标记 hash 值所映射的链表已经迁移完毕
2. 查询时，遇到 forwardingnode 就会去 nextTable 中进行查找

---

1.1 扩容机制和树化机制

1. 扩容机制

• 容量（capacity）
  • HashMap 底层数组 table 的长度，始终为 2 的幂次方
• 负载因子（load factor）
  • loadFactor，默认值 0.75
• 阈值（threshold）
  • 已存放元素个数超过 threshold = capacity * loadFactor 时，就触发扩容，每次扩容后重新计算
• 初次插入
  • 当第一次调用 put 时，如果 table 为空，则会先调用 resize()，默认初始化容量为 16（或用户指定的初始容量向上取到最近的 2 的幂）
• 插入后元素数超过阈值
  • 每次 put 后，若 size > threshold，则执行 resize() 扩容

2. 树化机制

• 链表转化为红黑树的两个前提条件
  • 链表长度超过阈值：当向同一个桶插入第 9 个元素（也就是链表长度 > TREEIFY_THRESHOLD，常量值 8）时，满足第一条件
  • 表的容量足够大：只有在当前 table.length ≥ MIN_TREEIFY_CAPACITY（常量值 64）时，才真正将链表树化；否则不树化，而是先触发一次扩容（resize），让更多的桶分摊这些节点

---

ConcurrentHashMap 为什么要加容量检查？

对于小表，链表查找开销尚小，扩容更有利于分散节点；等表足够大，才值得投入树化的维护成本

---

HashMap 和 ConcurrentHashMap 扩容机制和树化的总结：

TREEIFY_THRESHOLD = 8：链表长度超过 8 时尝试树化

MIN_TREEIFY_CAPACITY = 64：只有当表长 ≥ 64 时才做树化，否则先扩容

UNTREEIFY_THRESHOLD = 6：树中节点 ≤ 6 时退化为链表

扩容拆分：树节点在扩容时按高/低位拆分，分别树化或链表化

---

1.2 重要方法

// 获取 Node[] 中第 i 个 Node
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i)
 
// cas 修改 Node[] 中第 i 个 Node 的值, c 为旧值, v 为新值
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i, Node<K,V> c, Node<K,V> v)
 
// 直接修改 Node[] 中第 i 个 Node 的值, v 为新值
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v)

1.3 构造器分析

可以看到 ConcurrentHashMap 使用的是**懒惰初始化**，在构造方法中仅仅计算了 table 的大小，以后在第一次使用时才会真正创建

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel) // Use at least as many bins
        initialCapacity = concurrencyLevel; // as estimated threads
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
    // tableSizeFor 仍然是保证计算的大小是 2^n, 即 16,32,64 ... 
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    this.sizeCtl = cap;
}

1.4 get 流程

get 实现了无锁读取，但是并不保证一致性读取。ForwardingNode 发布前读旧桶，发布后读新表

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    // spread 把用户的 hashCode() 做一次高低位混洗，降低糟糕哈希（低位全 0）的碰撞概率；并保证结果是正数（配合位运算定位桶位）
    int h = spread(key.hashCode());
    // tabAt(...) 不是普通数组读，而是经由 Unsafe 的带内存语义的读取，保证是 happens‑before 且不加锁获取
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 如果头结点已经是要查找的 key
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                // 桶头命中 O(1) 的时间复杂度
                return e.val;
        }
        // hash 为负数表示该 bin 在扩容中或是 treebin, 这时调用 find 方法来查找
        else if (eh < 0)
            // find 函数会处理正在进行迁移的场景 以及 正常红黑树的场景
            return (p = e.find(h, key)) != null ? p.val : null;
        // 正常遍历链表, 用 equals 比较
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

get 方法的源码分析：首先判断桶头是否符合、再判断是否为特殊桶（红黑树或者 ForwardingNode）、走到这里就说明是链表判断了，直接循环遍历判断

● 如果 table 不为空且长度大于 0 且索引位置有元素
  ○ if 头节点 key 的 hash 值相等
    ■ 头节点的 key 指向同一个地址或者 equals
      ● 返回 value
  ○ else if 头节点的 hash 为负数（bin 在扩容或者是 treebin）
    ■ 调用 find 方法查找
  ○ 走到这里说明是正常链表遍历，进入循环（e 不为空）
    ■ 节点 key 的 hash 值相等，且 key 指向同一个地址或 equals
      ● 返回 value
● 返回 null

---

1.5 put 流程

以下数组简称（table），链表简称（bin）

public V put(K key, V value) {
    return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    // 其中 spread 方法会综合高位低位, 具有更好的 hash 性
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        // f 是链表头节点
        // fh 是链表头结点的 hash
        // i 是链表在 table 中的下标
        Node<K,V> f; int n, i, fh;
        // 要创建 table
        if (tab == null || (n = tab.length) == 0)
            // 初始化 table 使用了 cas, 无需 synchronized 创建成功, 进入下一轮循环
            tab = initTable();
        // 要创建链表头节点
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 添加链表头使用了 cas, 无需 synchronized
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;
        }
        // 帮忙扩容
        else if ((fh = f.hash) == MOVED)
            // 帮忙之后, 进入下一轮循环
            tab = helpTransfer(tab, f);
        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	(更新机制)
                            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;
                            // 已经是最后的节点了, 新增 Node, 追加至链表尾	(插入机制)
                            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;
                        // putTreeVal 会看 key 是否已经在树中, 是, 则返回对应的 TreeNode
                        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)
                    // 如果链表长度 >= 树化阈值(8), 进行链表转为红黑树
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 增加 size 计数
    addCount(1L, binCount);
    return null;
}
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
            Thread.yield();
        // 尝试将 sizeCtl 设置为 -1（表示初始化 table）
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            // 获得锁, 创建 table, 这时其它线程会在 while() 循环中 yield 直至 table 创建
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

// check 是之前 binCount 的个数 （addCount函数作用不仅是更新Map的Size数量，还能进行扩容的判断！）
private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    if (
        // 已经有了 counterCells, 向 cell 累加
        (as = counterCells) != null ||
        // 还没有, 向 baseCount 累加
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)
    ) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (
            // 还没有 counterCells
            as == null || (m = as.length - 1) < 0 ||
            // 还没有 cell
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            // cell cas 增加计数失败
            !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
        ) {
            // 创建累加单元数组和cell, 累加重试
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        // 获取元素个数
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                // newtable 已经创建了，帮忙扩容
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // 需要扩容，这时 newtable 未创建
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

先 spread 之后进行取桶 → 若 HashMap 未初始化，则执行 initTable（CAS 抢令牌） → 数组当前的桶空，就用 CAS 放头结点 → 桶在迁移则帮助迁移 helpTransfer → 否则对 bin 头加锁，链表插尾或树插 → 可能 treeify（但容量小先扩容）

用分段计数 addCount 增量并通过 sizeCtl 触发或协助扩容（ForwardingNode + 协作搬桶）

ConcurrentHashMap使用这两种手段来保证线程安全主要是一种权衡的考虑，在某些操作中使用synchronized，还是使用CAS，主要是根据锁竞争程度来判断的。

比如：在putVal中，如果计算出来的hash槽没有存放元素，那么就可以直接使用CAS来进行设置值，这是因为在设置元素的时候，因为hash值经过了各种扰动后，造成hash碰撞的几率较低，那么我们可以预测使用较少的自旋来完成具体的hash落槽操作。

当发生了hash碰撞的时候说明容量不够用了或者已经有大量线程访问了，因此这时候使用synchronized来处理hash碰撞比CAS效率要高，因为发生了hash碰撞大概率来说是线程竞争比较强烈

---

● 进入 for 循环：
  ○ if  table 为 null 或者长度为 0
    ■ 初始化表
  ○ else if 索引处无节点
    ■ 创建节点，填入 key 和 value，放入 table，退出循环
  ○ else if 索引处节点的 hash 值为 MOVE（ForwardingNode），表示正在扩容和迁移
    ■ 帮忙进行扩容
  ○ else
    ■ 利用 synchronized 锁住头节点
      ● if 再次确认头节点没有被移动
        ○ if  头节点 hash 值大于 0（表示这是一个链表）
          ■ 遍历链表找到对应 key，如果没有就进行创建
        ○ else if 节点为红黑树节点
          ■ 调用putTreeVal查看是否有对应 key 的数节点
            ● 如果有且为覆盖模式，将值覆盖，返回旧值
            ● 如果没有，创建并插入，返回 null
      ● 解锁
    ■ if binCount 不为 0
      ● 如果 binCount 大于树化阈值 8
        ○ 树化
      ● 如果旧值不为 null
        ○ 返回旧值
      ● break
● 增加 size 计数
● return null

---

1.6 size 计算流程

size 计算实际发生在 put，remove 改变集合元素的操作之中

• 没有竞争发生，向 baseCount 累加计数
• 有竞争发生，新建 counterCells，向其中的一个 cell 累加计
  • counterCells 初始有两个 cell
  • 如果计数竞争比较激烈，会创建新的 cell 来累加计数

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}
final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    // 将 baseCount 计数与所有 cell 计数累加
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

1.7 总结

Java 8 数组（Node） +（ 链表 Node | 红黑树 TreeNode ） 。JDK 8 的 ConcurrentHashMap 中，底层数组就是 Node[]，存放的都是 Node 或者它的子类，在数组中用 ForwardingNode 和 TreeBin 当哨兵，用 sizeCtl 标识扩容状态

以下数组称之为（table），链表简称（bin）

• 初始化，使用 cas 来保证并发安全，懒惰初始化 table
• 树化，当 table.length < 64 时，先尝试扩容，超过 64 时，并且 bin.length > 8 时，会将链表树化，树化过程 会用 synchronized 锁住链表头
• put，如果该 bin 尚未创建，只需要使用 cas 创建 bin；如果已经有了，锁住链表头进行后续 put 操作，元素添加至 bin 的尾部
• get，无锁操作仅需要保证可见性，所以 value 是被 volatile 修饰的。首先判断桶头；在判断是否为红黑树或者是正在扩容 ForwardingNode，那么它会让 get 操作在新 table 进行搜索；最后才是时间复杂度高的链表遍历
• 扩容，扩容时以 bin 为单位进行，需要对 bin 进行 synchronized，但这时妙的是其它竞争线程也不是无事可做，它们会帮助把其它 bin 进行扩容，扩容时平均只有 1/6 的节点会把复制到新 table 中
• size，元素个数保存在 baseCount 中，并发时的个数变动保存在 CounterCell[] 当中。最后统计数量时累加即可

(JDK 7)ConcurrentHashMap

它维护了一个 segment 数组，每个 segment 对应一把锁（就是继承 ReentrantLock）

• 优点：如果多个线程访问不同的 segment，实际是没有冲突的，这与 jdk8 中是类似的
• 缺点：Segments 数组默认大小为 16，这个容量初始化指定后就不能改变了，并且不是懒惰初始化

2.1 构造器分析

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // ssize 必须是 2^n, 即 2, 4, 8, 16 ... 表示了 segments 数组的大小
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    // segmentShift 默认是 32 - 4 = 28
    this.segmentShift = 32 - sshift;
    // segmentMask 默认是 15 即 0000 0000 0000 1111
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    // 创建 segments and segments[0]
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

构造完成，如下图所示

JDK 7 的 ConcurrentHashMap 没有实现懒惰初始化，所以空间占用相对来说不是很友好

其中this.segmentShift和this.segmentMask的作用是决定将 key 的 hash 结果匹配到哪个 segment

例如：根据某一 hash 值求 segment 位置，先将高位向低位移动 this.segmentShift 位

结果再与 this.segmentMask 做位于运算，最终得到 1010 即下标为 10 的 segment

---

2.2 put 流程

当第一次创建 Segement 的时候，需要保证安全性。JDK 7 使用的是 CAS 来确保创建 segement 是安全的

public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);
    // 计算出 segment 下标
    int j = (hash >>> segmentShift) & segmentMask;

    // 获得 segment 对象, 判断是否为 null, 是则创建该 segment
    if ((s = (Segment<K,V>)UNSAFE.getObject 
         (segments, (j << SSHIFT) + SBASE)) == null) {
        // 这时不能确定是否真的为 null, 因为其它线程也发现该 segment 为 null,
        // 因此在 ensureSegment 里用 cas 方式保证该 segment 安全性
        s = ensureSegment(j);
    }
    // 进入 segment 的 put 流程
    return s.put(key, hash, value, false);
}

segment 继承了可重入锁（ReentrantLock），它的 put 方法为

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    // 尝试加锁
    HashEntry<K,V> node = tryLock() ? null :
    // 如果不成功, 进入 scanAndLockForPut 流程
    // 如果是多核 cpu 最多 tryLock 64 次, 进入 lock 流程
    // 在尝试期间, 还可以顺便看该节点在链表中有没有, 如果没有顺便创建出来
    scanAndLockForPut(key, hash, value);

    // 执行到这里 segment 已经被成功加锁, 可以安全执行
    V oldValue;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry<K,V> first = entryAt(tab, index);
        for (HashEntry<K,V> e = first;;) {
            if (e != null) {
                // 更新
                K k;
                if ((k = e.key) == key ||
                    (e.hash == hash && key.equals(k))) { 
                    oldValue = e.value;
                    if (!onlyIfAbsent) {
                        e.value = value;
                        ++modCount;
                    } break;
                }
                e = e.next;
            }
            else {
                // 新增
                // 1) 之前等待锁时, node 已经被创建, next 指向链表头
                if (node != null)
                    node.setNext(first);
                else
                    // 2) 创建新 node
                    node = new HashEntry<K,V>(hash, key, value, first);
                int c = count + 1; 
                // 3) 扩容
                if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                    rehash(node);
                else
                    // 将 node 作为链表头
                    setEntryAt(tab, index, node);
                ++modCount;
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        unlock();
    }
    return oldValue;
}

2.3 rehash 流程

发生在 put 中，因为此时已经获得了锁，因此 rehash 时不需要考虑线程安全

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    int newCapacity = oldCapacity << 1;
    threshold = (int)(newCapacity * loadFactor);
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry[newCapacity];
    int sizeMask = newCapacity - 1;
    for (int i = 0; i < oldCapacity ; i++) {
        HashEntry<K,V> e = oldTable[i];
        if (e != null) {
            HashEntry<K,V> next = e.next;
            int idx = e.hash & sizeMask;
            if (next == null) // Single node on list
                newTable[idx] = e;
            else { // Reuse consecutive sequence at same slot
                HashEntry<K,V> lastRun = e;
                int lastIdx = idx;
                // 过一遍链表, 尽可能把 rehash 后 idx 不变的节点重用
                for (HashEntry<K,V> last = next;
                     last != null;
                     last = last.next) {
                    int k = last.hash & sizeMask;
                    if (k != lastIdx) {
                        lastIdx = k;
                        lastRun = last;
                    }
                }
                newTable[lastIdx] = lastRun;
                // 剩余节点需要新建
                for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry<K,V> n = newTable[k];
                    newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                }
            }
        }
    }
    // 扩容完成, 才加入新的节点
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;

    // 替换为新的 HashEntry table
    table = newTable;
}

附，调试代码

public static void main(String[] args) {
    ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
    for (int i = 0; i < 1000; i++) {
        int hash = hash(i);
        int segmentIndex = (hash >>> 28) & 15;
        if (segmentIndex == 4 && hash % 8 == 2) {
            System.out.println(i + "\t" + segmentIndex + "\t" + hash % 2 + "\t" + hash % 4 +
                               "\t" + hash % 8);
        }
    }
    map.put(1, "value");
    map.put(15, "value"); // 2 扩容为 4 15 的 hash%8 与其他不同
    map.put(169, "value");
    map.put(197, "value"); // 4 扩容为 8
    map.put(341, "value");
    map.put(484, "value");
    map.put(545, "value"); // 8 扩容为 16
    map.put(912, "value");
    map.put(941, "value");
    System.out.println("ok");
}
private static int hash(Object k) {
    int h = 0;
    if ((0 != h) && (k instanceof String)) {
        return sun.misc.Hashing.stringHash32((String) k);
    }
    h ^= k.hashCode();
    // Spread bits to regularize both segment and index locations,
    // using variant of single-word Wang/Jenkins hash.
    h += (h << 15) ^ 0xffffcd7d;
    h ^= (h >>> 10);
    h += (h << 3);
    h ^= (h >>> 6);
    h += (h << 2) + (h << 14);
    int v = h ^ (h >>> 16);
    return v;
}

2.4 get 流程

get 时并未加锁，用了 UNSAFE 方法保证了可见性。扩容过程中，get 先发生就从旧表取内容，get 后发生就从新表取内容

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key);
    // u 为 segment 对象在数组中的偏移量
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    // s 即为 segment
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
             (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

2.5 size 计算流程

• 计算元素个数前，先不加锁计算两次，如果前后两次结果如一样，认为个数正确返回
• 如果不一样，进行重试，重试次数超过 3，将所有 segment 锁住，重新计算个数返回

public int size() {
    // Try a few times to get accurate count. On failure due to
    // continuous async changes in table, resort to locking.
    final Segment<K,V>[] segments = this.segments;
    int size;
    boolean overflow; // true if size overflows 32 bits
    long sum; // sum of modCounts
    long last = 0L; // previous sum
    int retries = -1; // first iteration isn't retry
    try {
        for (;;) {
            if (retries++ == RETRIES_BEFORE_LOCK) {
                // 超过重试次数, 需要创建所有 segment 并加锁
                for (int j = 0; j < segments.length; ++j)
                    ensureSegment(j).lock(); // force creation
            }
            sum = 0L;
            size = 0;
            overflow = false;
            for (int j = 0; j < segments.length; ++j) {
                Segment<K,V> seg = segmentAt(segments, j);
                if (seg != null) {
                    sum += seg.modCount;
                    int c = seg.count;
                    if (c < 0 || (size += c) < 0)
                        overflow = true;
                }
            }
            if (sum == last)
                break;
            last = sum;
        }
    } finally {
        if (retries > RETRIES_BEFORE_LOCK) {
            for (int j = 0; j < segments.length; ++j)
                segmentAt(segments, j).unlock();
        }
    }
    return overflow ? Integer.MAX_VALUE : size;
}

3. JDK 7 和 JDK 8 的对比

1. 锁粒度更细、写路径更轻

• JDK 7 ：Segment[] + 每段一个 ReentrantLock。同一段内所有写操作（含扩容）互斥，并发度最多≈segment 个数（默认 16），高并发时容易撞同一段产生激烈竞争。
• JDK 8 ：无 Segment ，底层是单个 Node[]。
  • 空桶插入：CAS 直接放表头（无需锁）。
  • 非空桶插入/更新：只对**该桶头节点 ****synchronized(f)**（bin 级锁），其他桶不受影响。写竞争范围从"段"缩小到"桶"，碰撞概率大幅下降。

2. 扩容是"可并行的"，而不是"锁住一段慢慢搬"

• JDK 7 ：扩容在 Segment 内部执行，拿着段锁串行搬迁；段内其他写会被阻塞。
• JDK 8 ：协作式扩容 。迁移一个桶后把桶头置为 ForwardingNode（hash<0），其他线程 get/put 碰到就自动转发 到新表，并且还能顺手帮忙搬 一段（helpTransfer）。扩容期间读写不中断、多线程并行搬迁，整体停顿时间小得多

3. 高碰撞退化从 O(n) 降到 O(log n)

• JDK 7 ：没有树化，恶意/糟糕哈希下长链退化 O(n)。
• JDK 8 ：当桶长度达到阈值（且表容量足够）⇒ 树化为红黑树 （通过 TreeBin 管理），查找/更新 O(log n)。 在"热点键/大量碰撞"的场景，JDK 8 优势非常明显。

4. 更轻的计数与扩容判定

• JDK 7 ：段内 count 受段锁保护，统计/扩容判定伴随锁竞争。
• JDK 8 ：LongAdder 风格 的分散计数（baseCount + CounterCells[]），addCount 里的扩容触发通过 sizeCtl 状态机 + CAS 进行。 高并发下减少同一计数点的争用，扩容触发更平滑。

5. 更好的缓存局部性 & 更少对象层级

• JDK 7 ：Segment[] → HashEntry[] → HashEntry 链，层级多、跨对象跳转多。
• JDK 8 ：直接 Node[]，再到链表/树。层级更扁平，CPU Cache 友好。

6. 读路径同为无锁，但 JDK 8 更"顺滑"

• 两代的 get 都是无锁读取（volatile/Unsafe 有序读）。
• JDK 8 在扩容时靠 ForwardingNode在线转发 到新表；JDK 7 是按段切换整张表。在实际高并发、频繁扩容场景下，JDK 8 的读更少受写时"热点段"的拖累