public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    // h是当前元素算出的下标
    int h = spread(key.hashCode());
    // e是h桶的第一个元素
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 第一个元素e.key刚好equals要找的key，那就直接返回e.val
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // eh小于0的话，有三种情况-1正在扩容，-2是tree的根节点，-3是一个受保护的节点
        // 运行find方法找，对于不同节点类型的find方法是重写的
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;


        // 当前坑位有别人，并且hash还是正常的>0，那么就是链表一直往下找就行
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}
Copy

/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();


    // 首先求出hash，算下标用
    int hash = spread(key.hashCode());
    int binCount = 0;
    
    // 进入一个循环
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh; K fk; V fv;

        // 数组还没初始化，就去初始化先，回来后继续循环
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();

        // 初始化了，那就用cas判断下标位置是不是null，是的话set进去，搞定
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                break;                   // no lock when adding to empty bin
        }

        // MOVED是-1，也就是ForwardingNode，即所在的桶的所有节点都搬家到新tab了，
        // 且有其他桶子还在搬家，那当前线程就帮其他桶子搬家，因为put得搬完了才能插入
        // 所以自己闲着也是闲着，不如搭把手。
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);

        // onlyIfAbsent是putIfAbsent方法才是true，我们先不管这个分支
        else if (onlyIfAbsent // check first node without acquiring lock
                 && fh == hash
                 && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                 && (fv = f.val) != null)
            return fv;

        // 如果不是正在扩容，桶首节点也有人占了，那么我们需要往后插入
        // 这时候还有链表/树节点判断，各自又有不同的操作，所以直接把整个桶子锁住
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    //正常Node，就按照链表的思路找到该节点setval或者找不到就追加到最后
                    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;
                                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;
                            }
                        }
                    }

                    // 树的插入，putTreeVal中是有锁住TreeBin中的state的，因为这里的synchronized只是在put的过程中互斥，也就是对一个桶的写操作互斥
                    // 但是get与put不互斥，我们之前说过树的Rebalance会导致get懵逼
                    // 因而putTreeVal中还有一层cas锁
                    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;
                        }
                    }

                    // 暂时不管这个类型的node
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }

            // binCount记录当前桶子节点数，主要是链表，如果链表>=8则树化
            // treeifyBin中会先判断是不是tabsize>=64了，是才树化，否则就只是扩容一下
            // 树化操作也会对当前桶子加synchronize锁，防止并发树化，或者并发树化+put
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)//8
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // addCount是增加总容量的记录，该方法中还会判断是否大于sizeCtl了
    // 如果大于则会触发扩容
    addCount(1L, binCount);
    return null;
}
Copy

private final void addCount(long x, int check) {
    ......
    // 当size大于sizeCtl的时候就开始扩容
    while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {

        // rs一个标识，他的计算逻辑在下面
        int rs = resizeStamp(n);
        
        // sizeCtl是负数说明其他线程已经触发且正在扩容了
        if (sc < 0) {
            if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                transferIndex <= 0)
                break;
            // 没啥问题的话，sc+1，当前线程也帮忙搬家
            if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1))
                transfer(tab, nt);
        }

        // 正常情况下sc通过cas设置为一个n(oldsize)相关的负数，并开始扩容
        else if (U.compareAndSetInt(this, SIZECTL, sc,
                                     (rs << RESIZE_STAMP_SHIFT) + 2))
            transfer(tab, null);
        s = sumCount();
    }
    ......

// n=tabsize
// Integer.numberOfLeadingZeros(n)这个int前面的0的个数，最多31个0,即1-31范围
// 然后对第15bit置1，这个的作用是上面rs << RESIZE_STAMP_SHIFT(32-16)的取值一定是负值
static final int resizeStamp(int n) {
    return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
Copy

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    // stride最小取16
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // subdivide range 
    
    // 这一段是new新的数组
    if (nextTab == null) {            // initiating
        try {
            @SuppressWarnings("unchecked")
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {      // try to cope with OOME
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        nextTable = nextTab;
        transferIndex = n;
    }

    // 直接跳到后面实际操作的部分，下面几行不是很重要
    int nextn = nextTab.length;
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    boolean advance = true;
    boolean finishing = false; // to ensure sweep before committing nextTab
    for (int i = 0, bound = 0;;) {
        Node<K,V> f; int fh;
        while (advance) {
            int nextIndex, nextBound;
            if (--i >= bound || finishing)
                advance = false;
            else if ((nextIndex = transferIndex) <= 0) {
                i = -1;
                advance = false;
            }
            else if (U.compareAndSetInt
                     (this, TRANSFERINDEX, nextIndex,
                      nextBound = (nextIndex > stride ?
                                   nextIndex - stride : 0))) {
                bound = nextBound;
                i = nextIndex - 1;
                advance = false;
            }
        }
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            if (finishing) {
                nextTable = null;
                table = nextTab;
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }
            if (U.compareAndSetInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        else {

            /*******************实际的扩容操作************************/
            // 逐个桶子扩容，锁住当前桶子，使扩容的时候无法进行put和treeifyBin等操作
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    // fh>0正常的链表节点
                    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;
                        }

                        // 当前位置的node在扩容后会放到同样的下标位置，或者i+n的位置，这样分别生成对应的两条链表
                        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);
                        }
                        // 将ln放到i位置，hn放到i+n位置，然后把原tab的桶子里放个forward节点，fwd指向newTab
                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }


                    // 对于树节点稍微复杂一些，对i和i+n位置存储的，可能是树，也可能需要退化成链表，其他的差不多。
                    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;
                    }
                }
            }
        }
    }
}
Copy

// 常见错误用法: 
// 只能保证单句函数没有并发问题的，contains这句之后，可能瞬间被其他线程remove,后面get出null
// 或者get出来的是10，但是另一个线程也执行到这一行也get了10，最后期望两个+1结果是12，但是set了11回去。
static void add(Map<String, Integer> map, String key) {
    if (map.containsKey(key)) {
        map.put(key, map.get(key) + 1);
    } else {
        map.put(key, 1);
    }
}



// 正确用法，使用ConcurrentHashMap提供的有并发保障的单函数putIfAbsent来处理不包含的场景
// 然后replace这种cas配合自旋保证读取+插入的原子性
static void add(Map<String, Integer> map, String key) {
    while (true) {
        var oldValue = map.putIfAbsent(key, 1);
        if (oldValue == null || map.replace(key, oldValue, oldValue + 1)) {
            break;
        }
    }
}

Copy

  /* The HashMap class holds the following invariant:
   * - For each i between  0 and table.length, the bucket at table(i) only contains keys whose hash-index is i.
   * - Every bucket is sorted in ascendent hash order
   * - The sum of the lengths of all buckets is equal to contentSize.
   */
Copy