JDK1.8 ConcurrentHashMap擴容函數註釋

原文鏈接：https://www.jianshu.com/p/2829fe36a8dd

轉自：https://www.jianshu.com/p/2829fe36a8dd

/**
 * Moves and/or copies the nodes in each bin to new table. See
 * above for explanation.
 * 
 * transferIndex 表示轉移時的下標，初始爲擴容前的 length。
 * 
 * 我們假設長度是 32
 */
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    // 將 length / 8 然後除以 CPU核心數。如果得到的結果小於 16，那麼就使用 16。
    // 這裏的目的是讓每個 CPU 處理的桶一樣多，避免出現轉移任務不均勻的現象，如果桶較少的話，默認一個 CPU（一個線程）處理 16 個桶
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // subdivide range 細分範圍 stridea：TODO
    // 新的 table 尚未初始化
    if (nextTab == null) {            // initiating
        try {
            // 擴容  2 倍
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
            // 更新
            nextTab = nt;
        } catch (Throwable ex) {      // try to cope with OOME
            // 擴容失敗， sizeCtl 使用 int 最大值。
            sizeCtl = Integer.MAX_VALUE;
            return;// 結束
        }
        // 更新成員變量
        nextTable = nextTab;
        // 更新轉移下標，就是 老的 tab 的 length
        transferIndex = n;
    }
    // 新 tab 的 length
    int nextn = nextTab.length;
    // 創建一個 fwd 節點，用於佔位。當別的線程發現這個槽位中是 fwd 類型的節點，則跳過這個節點。
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    // 首次推進爲 true，如果等於 true，說明需要再次推進一個下標（i--），反之，如果是 false，那麼就不能推進下標，需要將當前的下標處理完畢才能繼續推進
    boolean advance = true;
    // 完成狀態，如果是 true，就結束此方法。
    boolean finishing = false; // to ensure sweep before committing nextTab
    // 死循環,i 表示下標，bound 表示當前線程可以處理的當前桶區間最小下標
    for (int i = 0, bound = 0;;) {
        Node<K,V> f; int fh;
        // 如果當前線程可以向後推進；這個循環就是控制 i 遞減。同時，每個線程都會進入這裏取得自己需要轉移的桶的區間
        while (advance) {
            int nextIndex, nextBound;
            // 對 i 減一，判斷是否大於等於 bound （正常情況下，如果大於 bound 不成立，說明該線程上次領取的任務已經完成了。那麼，需要在下面繼續領取任務）
            // 如果對 i 減一大於等於 bound（還需要繼續做任務），或者完成了，修改推進狀態爲 false，不能推進了。任務成功後修改推進狀態爲 true。
            // 通常，第一次進入循環，i-- 這個判斷會無法通過，從而走下面的 nextIndex 賦值操作（獲取最新的轉移下標）。其餘情況都是：如果可以推進，將 i 減一，然後修改成不可推進。如果 i 對應的桶處理成功了，改成可以推進。
            if (--i >= bound || finishing)
                advance = false;// 這裏設置 false，是爲了防止在沒有成功處理一個桶的情況下卻進行了推進
            // 這裏的目的是：1. 當一個線程進入時，會選取最新的轉移下標。2. 當一個線程處理完自己的區間時，如果還有剩餘區間的沒有別的線程處理。再次獲取區間。
            else if ((nextIndex = transferIndex) <= 0) {
                // 如果小於等於0，說明沒有區間了 ，i 改成 -1，推進狀態變成 false，不再推進，表示，擴容結束了，當前線程可以退出了
                // 這個 -1 會在下面的 if 塊裏判斷，從而進入完成狀態判斷
                i = -1;
                advance = false;// 這裏設置 false，是爲了防止在沒有成功處理一個桶的情況下卻進行了推進
            }// CAS 修改 transferIndex，即 length - 區間值，留下剩餘的區間值供後面的線程使用
            else if (U.compareAndSwapInt
                     (this, TRANSFERINDEX, nextIndex,
                      nextBound = (nextIndex > stride ?
                                   nextIndex - stride : 0))) {
                bound = nextBound;// 這個值就是當前線程可以處理的最小當前區間最小下標
                i = nextIndex - 1; // 初次對i 賦值，這個就是當前線程可以處理的當前區間的最大下標
                advance = false; // 這裏設置 false，是爲了防止在沒有成功處理一個桶的情況下卻進行了推進，這樣對導致漏掉某個桶。下面的 if (tabAt(tab, i) == f) 判斷會出現這樣的情況。
            }
        }// 如果 i 小於0 （不在 tab 下標內，按照上面的判斷，領取最後一段區間的線程擴容結束）
        //  如果 i >= tab.length(不知道爲什麼這麼判斷)
        //  如果 i + tab.length >= nextTable.length  （不知道爲什麼這麼判斷）
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            if (finishing) { // 如果完成了擴容
                nextTable = null;// 刪除成員變量
                table = nextTab;// 更新 table
                sizeCtl = (n << 1) - (n >>> 1); // 更新閾值
                return;// 結束方法。
            }// 如果沒完成
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {// 嘗試將 sc -1. 表示這個線程結束幫助擴容了，將 sc 的低 16 位減一。
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)// 如果 sc - 2 不等於標識符左移 16 位。如果他們相等了，說明沒有線程在幫助他們擴容了。也就是說，擴容結束了。
                    return;// 不相等，說明沒結束，當前線程結束方法。
                finishing = advance = true;// 如果相等，擴容結束了，更新 finising 變量
                i = n; // 再次循環檢查一下整張表
            }
        }
        else if ((f = tabAt(tab, i)) == null) // 獲取老 tab i 下標位置的變量，如果是 null，就使用 fwd 佔位。
            advance = casTabAt(tab, i, null, fwd);// 如果成功寫入 fwd 佔位，再次推進一個下標
        else if ((fh = f.hash) == MOVED)// 如果不是 null 且 hash 值是 MOVED。
            advance = true; // already processed // 說明別的線程已經處理過了，再次推進一個下標
        else {// 到這裏，說明這個位置有實際值了，且不是佔位符。對這個節點上鎖。爲什麼上鎖，防止 putVal 的時候向鏈表插入數據
            synchronized (f) {
                // 判斷 i 下標處的桶節點是否和 f 相同
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;// low, height 高位桶，低位桶
                    // 如果 f 的 hash 值大於 0 。TreeBin 的 hash 是 -2
                    if (fh >= 0) {
                        // 對老長度進行與運算（第一個操作數的的第n位於第二個操作數的第n位如果都是1，那麼結果的第n爲也爲1，否則爲0）
                        // 由於 Map 的長度都是 2 的次方（000001000 這類的數字），那麼取於 length 只有 2 種結果，一種是 0，一種是1
                        //  如果是結果是0 ，Doug Lea 將其放在低位，反之放在高位，目的是將鏈表重新 hash，放到對應的位置上，讓新的取於算法能夠擊中他。
                        int runBit = fh & n;
                        Node<K,V> lastRun = f; // 尾節點，且和頭節點的 hash 值取於不相等
                        // 遍歷這個桶
                        for (Node<K,V> p = f.next; p != null; p = p.next) {
                            // 取於桶中每個節點的 hash 值
                            int b = p.hash & n;
                            // 如果節點的 hash 值和首節點的 hash 值取於結果不同
                            if (b != runBit) {
                                runBit = b; // 更新 runBit，用於下面判斷 lastRun 該賦值給 ln 還是 hn。
                                lastRun = p; // 這個 lastRun 保證後面的節點與自己的取於值相同，避免後面沒有必要的循環
                            }
                        }
                        if (runBit == 0) {// 如果最後更新的 runBit 是 0 ，設置低位節點
                            ln = lastRun;
                            hn = null;
                        }
                        else {
                            hn = lastRun; // 如果最後更新的 runBit 是 1， 設置高位節點
                            ln = null;
                        }// 再次循環，生成兩個鏈表，lastRun 作爲停止條件，這樣就是避免無謂的循環（lastRun 後面都是相同的取於結果）
                        for (Node<K,V> p = f; p != lastRun; p = p.next) {
                            int ph = p.hash; K pk = p.key; V pv = p.val;
                            // 如果與運算結果是 0，那麼就還在低位
                            if ((ph & n) == 0) // 如果是0 ，那麼創建低位節點
                                ln = new Node<K,V>(ph, pk, pv, ln);
                            else // 1 則創建高位
                                hn = new Node<K,V>(ph, pk, pv, hn);
                        }
                        // 其實這裏類似 hashMap 
                        // 設置低位鏈表放在新鏈表的 i
                        setTabAt(nextTab, i, ln);
                        // 設置高位鏈表，在原有長度上加 n
                        setTabAt(nextTab, i + n, hn);
                        // 將舊的鏈表設置成佔位符
                        setTabAt(tab, i, fwd);
                        // 繼續向後推進
                        advance = true;
                    }// 如果是紅黑樹
                    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);
                            // 和鏈表相同的判斷，與運算 == 0 的放在低位
                            if ((h & n) == 0) {
                                if ((p.prev = loTail) == null)
                                    lo = p;
                                else
                                    loTail.next = p;
                                loTail = p;
                                ++lc;
                            } // 不是 0 的放在高位
                            else {
                                if ((p.prev = hiTail) == null)
                                    hi = p;
                                else
                                    hiTail.next = p;
                                hiTail = p;
                                ++hc;
                            }
                        }
                        // 如果樹的節點數小於等於 6，那麼轉成鏈表，反之，創建一個新的樹
                        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;
                    }
                }
            }
        }
    }
}