final V putVal(K key, V value, boolean onlyIfAbsent) {
    // key 和 value 都不能为 null（区别于 HashMap）
    if (key == null || value == null) throw new NullPointerException();

    int hash = spread(key.hashCode()); // 扰动计算
    int binCount = 0;

    // 自旋（CAS 失败就重试）
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;

        // ① 数组未初始化 → 初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();

        // ② 当前桶为空 → CAS 存放（无锁）
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                break;
        }

        // ③ 正在扩容 → 协助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);

        // ④ 发生 hash 冲突 → synchronized 锁住当前桶的 head
        else {
            V oldVal = null;
            synchronized (f) { // 只锁链表/红黑树的头节点
                if (tabAt(tab, i) == f) { // 双重检查
                    if (fh >= 0) { // 链表
                        binCount = 1;
                        for (Node<K,V> e = f;; e = e.next) {
                            // 找到 key 覆盖 value
                            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) { // 红黑树
                        // 向红黑树插入节点
                    }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD) // >= 8 转红黑树
                    treeifyBin(tab, i);
                if (oldVal != null) return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount); // 增加计数
    return null;
}

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;
        }
        // ③ hash 为负 → 红黑树或正在扩容，用 find() 查找
        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;
}

// 不加锁的累加方式
// sumCount() 累加 baseCount + CounterCell[]
public int size() {
    long n = sumCount();
    return (n < 0L) ? 0 : (n > Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int)n;
}

// CounterCell 是什么？
// 多个线程同时 addCount() 时，CAS 更新 baseCount。
// 如果 CAS 失败（竞争激烈），不重试而是用 CounterCell 数组分散写入。
// sumCount() 时累加 baseCount + 所有 CounterCell 的值。

// 扩容时，链表会拆成低位链和高位链
// 低位链：hash & oldCap == 0 → 放在 newTab[i]
// 高位链：hash & oldCap != 0 → 放在 newTab[i + oldCap]

// 例：oldCap = 16，扩容到 32
// 元素 hash 的 index = (n-1) & hash
// 扩容前：hash & 15      → 得到原索引
// 扩容后：hash & 31      → 要么原索引，要么原索引+16
//            ↓
// 用 hash & 16（oldCap）判断：
//   为 0 → 新索引不变
//   为 1 → 新索引 = 原索引 + 16