ConcurrentHashMap 演进：JDK7 分段锁 → JDK8 CAS+synchronized

// 外层：Segment 数组，final 不可变，构造后并发度固定
final Segment<K,V>[] segments;

// 定位段：用 hash 的高位（segmentShift / segmentMask）
final int segmentShift;   // = 32 - sshift，默认 28
final int segmentMask;    // = ssize - 1，默认 15

// 段：一把可重入锁 + 一张独立的哈希表
static final class Segment<K,V> extends ReentrantLock {
    transient volatile HashEntry<K,V>[] table;
    transient volatile int count;      // 段内元素个数
    transient int modCount;              // 段内修改次数（size 统计用）
    transient int threshold;             // 段内扩容阈值 = table.length × loadFactor
    final float loadFactor;
}

// 节点：next 也是 volatile —— get 无锁遍历的根基
static final class HashEntry<K,V> {
    final int hash;
    final K key;
    volatile V value;
    volatile HashEntry<K,V> next;
}

HashEntry<K,V> node = tryLock() ? null
                                : scanAndLockForPut(key, hash, value);
try {
    HashEntry<K,V>[] tab = table;
    int index = (tab.length - 1) & hash;      // 段内定位（低位取模）
    HashEntry<K,V> first = entryAt(tab, index);
    // 遍历：命中则更新 value；未命中则……
    node.setNext(first);                        // 头插法！新节点插到链表头部
    int c = count + 1;
    if (c > threshold && tab.length < MAXIMUM_CAPACITY)
        rehash(node);                           // 段内扩容：表长 × 2（含 lastRun 优化）
    else
        setEntryAt(tab, index, node);
    count = c;
} finally {
    unlock();                                   // 锁的正是 Segment 自己（ReentrantLock）
}

// RETRIES_BEFORE_LOCK = 2：先无锁统计两遍
for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
    // 遍历所有 Segment，累加 count，同时记录每个段的 modCount；
    // 若两次统计间所有 modCount 都没变 → 认为结果稳定，直接返回
}
// 两遍都不稳定 → 兜底：锁住【所有】Segment 再累加
for (int i = 0; i < segments.length; ++i)
    segments[i].lock();
// …… 累加 count 后逐个 unlock

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;                 // 与 HashMap 不同：val 是 volatile
    volatile Node<K,V> next;         // next 也是 volatile
}

// 哈希标记：负值不会与真实 hash 冲突（真实 hash 经 HASH_BITS 清符号位）
static final int MOVED     = -1;   // ForwardingNode：该桶已迁移，去新表找
static final int TREEBIN   = -2;   // TreeBin：该桶已树化
static final int RESERVED  = -3;   // ReservationNode：占位（compute 等用）
static final int HASH_BITS = 0x7fffffff; // spread 后清掉符号位

// 阈值常量（面试必须脱口而出）
static final int TREEIFY_THRESHOLD = 8;      // 链表转树阈值
static final int UNTREEIFY_THRESHOLD = 6;   // 树退化链表阈值
static final int MIN_TREEIFY_CAPACITY = 64;  // 树化的最小数组长度
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int DEFAULT_CAPACITY = 16;
static final int MAXIMUM_CAPACITY = 1 << 30;

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();   // 别人在初始化，让出 CPU
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    table = tab = new Node<?,?>[n];
                    sc = n - (n >>> 2);              // 阈值 = 0.75n
                }
            } finally { sizeCtl = sc; }
            break;
        }
    }
    return tab;
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null)          // ① 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;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();                      // ③ 懒初始化
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value))) // ④ 空桶：CAS 无锁插入
                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;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;     // 命中：更新（volatile 写）
                                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)
                        ...putTreeVal...             // 树桶：按红黑树插入
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)   // ⑦ 树化检查
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);                       // ⑧ 计数 + 扩容检查
    return null;
}

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n, sc;
    if (tab != null) {
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)   // 数组 < 64
            tryPresize(n << 1);                        // 先扩容 2 倍，不树化
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            synchronized (b) {                     // 锁头节点，改造成 TreeBin
                if (tabAt(tab, index) == b) {
                    TreeNode<K,V> hd = null, tl = null;
                    for (Node<K,V> e = b; e != null; e = e.next) {
                        TreeNode<K,V> p = new TreeNode<>(e.hash, e.key, e.val, null, null);
                        // 双向链表串联……
                    }
                    setTabAt(tab, index, new TreeBin<>(hd)); // 头节点换成 TreeBin(hash=-2)
                }
            }
        }
    }
}

final long sumCount() {
    CounterCell[] as = counterCells;
    long sum = baseCount;                    // 主计数器
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            CounterCell a;
            if ((a = as[i]) != null)
                sum += a.value;                 // 加上各分条
        }
    }
    return sum;
}

public int size() {                          // int 版本，溢出截断到 MAX_VALUE
    long n = sumCount();
    return (n < 0L) ? 0 : (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int)n;
}

public long mappingCount() {                 // long 版本，推荐用它
    long n = sumCount();
    return (n < 0L) ? 0L : n;
}

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;
        }
        else if (eh < 0)                        // MOVED / TREEBIN / RESERVED
            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;
}

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel)   // 只用来「垫高」初始容量
        initialCapacity = concurrencyLevel;    // 不再决定并发度！
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    this.sizeCtl = cap;                       // 预置首表容量与阈值
}

ConcurrentHashMap<String, Long> stats = new ConcurrentHashMap<>();
stats.merge("error", 1L, Long::sum);     // 不存在→1，存在→+1，全程原子

V v = cache.get(key);                       // ① 无锁预检查，命中直接返回
if (v == null) {
    V loaded = loadFromDb(key);             // ② 慢 IO 在【锁外】完成
    if (loaded != null)
        v = cache.putIfAbsent(key, loaded);  // ③ 锁内只做引用赋值，快
    return (v != null) ? v : loaded;
}
return v;

// 已知将写入 100_000 条：new CHM(100_000)，sizeCtl 自动预置合适首表容量
ConcurrentHashMap<String, Object> cache =
    new ConcurrentHashMap<>(100_000);

// 一个 key 打爆一个桶？把计数拆成 N 份，读取时求和
LongAdder[] cells = new LongAdder[16];
// 写：cells[ThreadLocalRandom.current().nextInt(16)].increment();
// 读：Stream.of(cells).mapToLong(LongAdder::sum).sum();