多線程（十六、ConcurrentHashMap原理（3）擴容）

擴容的原理

擴容一般分為2個步驟

1、table數組的擴容，一般是2倍的擴容，這個是單線程操作的。

2、數據的遷移，把舊table中的各個槽中的結點重新分配到新table中。

ConcurrentHashMap在處理rehash的時候，并不會重新計算每個key的hash值，而是利用了一種很巧妙的方法。

1、ConcurrentHashMap內部的table數組的大小必須為2的冪次，原因是讓key均勻分布，減少沖突
2、當table數組的大小為2的冪次時，通過key.hash & table.length-1這種方式計算出的索引i，當table擴容后（2倍），新的索引要么在原來的位置i，要么是i+n，n為擴容之前的容量。
3、這種處理方式非常利于擴容時多個線程同時進行的數據遷移操作，因為舊table的各個桶中的結點遷移不會互相影響，將整個table數組劃分為很多部分，每一部分包含一定區間的桶，每個數據遷移線程處理各自區間中的結點

什么時候擴容？

鏈表的結點數目超過一定閾值，就會觸發鏈表 -> 紅黑樹的轉換，執行treeifyBin方法。

/**
 *  鏈表 -> 紅黑樹 的轉換.
 */
private final void treeifyBin(Node<K, V>[] tab, int index) {
    Node<K, V> b;
    int n, sc;
    if (tab != null) {

        // CASE 1: table的容量 < MIN_TREEIFY_CAPACITY(64)時，直接table擴容，不紅黑樹轉換
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            tryPresize(n << 1); //左移一位，就是*2，擴容2倍

            // CASE 2: table的容量 ≥ MIN_TREEIFY_CAPACITY(64)時，鏈表 -> 紅黑樹的轉換
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            synchronized (b) {
                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<K, V>(e.hash, e.key, e.val, null, null);
                        if ((p.prev = tl) == null)
                            hd = p;
                        else
                            tl.next = p;
                        tl = p;
                    }
                    // 封裝TreeBin，并鏈接到table[index]中
                    setTabAt(tab, index, new TreeBin<K, V>(hd));
                }
            }
        }
    }
}

擴容函數tryPresize

private final void tryPresize(int size) {
        //動態調整擴容的大小
        int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
                tableSizeFor(size + (size >>> 1) + 1);
        int sc;
        while ((sc = sizeCtl) >= 0) { //大于等于0代表，初始化或者擴容后的（table*負載因子）的桶數量
            Node<K,V>[] tab = table; int n;
            //Case1，table沒有初始化，先初始化
            if (tab == null || (n = tab.length) == 0) {
                n = (sc > c) ? sc : c;
                //設置SIZECTL為-1代表，初始化或者擴容進行中
                if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                    try {
                        if (table == tab) {
                            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];//生成新的table
                            table = nt;
                            sc = n - (n >>> 2); //n-(n/4) = 0.75n,也就是負載因子
                        }
                    } finally {
                        sizeCtl = sc; //設置sizeCtl為擴容后的桶*負載因子
                    }
                }
            }
            //Case2, c<sc說明已經擴容了；n>=MAXIMUM_CAPACITY,說明桶超限了。
            else if (c <= sc || n >= MAXIMUM_CAPACITY)
                break;
            //Case3,開始擴容
            else if (tab == table) {
                int rs = resizeStamp(n);//根據容量n生成一個隨機數，唯一標識本次擴容操作
                if (sc < 0) { //sc<0,說明sizeCtl<0,代表有別的線程正在進行擴容
                    Node<K,V>[] nt;
                    //不能協助擴容，退出
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                            sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                            transferIndex <= 0)
                        break;
                    //加入擴容的隊伍，同時sizeCtl+1，此時sizeCtl代表擴容的線程數量
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                        transfer(tab, nt);
                }
                //設置sizeCtl為負數，代表自己是第一個擴容的線程，CAS操作保證只有一個線程安全
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                        (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null); //null代表首次擴容
            }
        }
    }

數據遷移方法transfer

/**
     * tab,    舊table
     * nextTAB 擴容后的table
     */
    private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        //每個線程負責遷移table一個區間段的桶的個數，最少是16個
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        //首次擴容
        if (nextTab == null) {            // initiating
            try {
                //創建新的table,默認n*2
                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;
        //創建擴容節點，當某個桶遷移完成后，放入table[i],標記桶擴容完成
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        boolean advance = true; //為true,表示當前桶遷移完成，可以繼續處理下一個桶
        boolean finishing = false; // 最后一個數據遷移的線程將該值置為true，進行擴容的收尾工作
        //i桶索引，bound就是線程要處理的另一個區間邊界
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            //定位本輪處理區間【transferIndex-1，transferIndex-stride】
            while (advance) {
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                else if (U.compareAndSwapInt
                        (this, TRANSFERINDEX, nextIndex,
                                nextBound = (nextIndex > stride ?
                                        nextIndex - stride : 0))) {
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            //Case1,最后一個遷移線程或者是線程出現了沖突，導致了i<0
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                if (finishing) { //遷移完成
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                //擴容線程數減1,當前線程任務已執行完成
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    //判斷是否最后一個遷移線程，不是則退出
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    //最后一個線程，還原i值，重新進行檢查，是否全部遷移完成，應該所有桶都是ForwardingNode
                    i = n; // recheck before commit
                }
            }
            // CASE2：舊桶本身為null，不用遷移，放一個ForwardingNode
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            //CASE3：該舊桶已經遷移完成，直接跳過，hash==moved 代表ForwardingNode
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
                // CASE4：該舊桶未遷移完成，進行數據遷移，加鎖
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        if (fh >= 0) { //桶是鏈表，遷移鏈表

                            /**
                             * 下面的過程會將舊桶中的鏈表分成兩部分：ln鏈和hn鏈
                             * ln鏈會插入到新table的槽i中，hn鏈會插入到新table的槽i+n中
                             */
                            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;
                            }
                            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);
                            }
                            setTabAt(nextTab, i, ln);  // ln鏈表存入新桶的索引i位置
                            setTabAt(nextTab, i + n, hn); // hn鏈表存入新桶的索引i+n位置
                            setTabAt(tab, i, fwd); // 設置ForwardingNode占位
                            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;
                            /**
                             * 先以鏈表方式遍歷，復制所有結點，然后根據高低位組裝成兩個鏈表；
                             * 然后看下是否需要進行紅黑樹轉換，最后放到新table對應的桶中
                             */
                            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);// 設置ForwardingNode占位
                            advance = true; // 表示當前舊桶的結點已遷移完畢
                        }
                    }
                }
            }
        }
    }