private transient volatile Node<K,V>[] nextTable; //僅僅在擴容使用，並且此時非空

// 將table每一個bin（桶位）的Node移動或複製到nextTable
// 只在addCount(long x, int check)、helpTransfer、tryPresize中呼叫
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride; 
    // 每核處理的量小於16，則強制賦值16
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // subdivide range
    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;
    //連節點指標,標誌位，fwd的hash值為-1，fwd.nextTable=nextTab。
    ForwardingNode<K,V> fwd= new ForwardingNode<K,V>(nextTab);
    boolean advance= true;//併發擴容的關鍵屬性,等於true,說明此節點已經處理過
    boolean finishing = false; // to ensure sweep before committing nextTab
    for (int i = 0, bound = 0;;) { // 死迴圈
        Node<K,V> f; int fh;
        while (advance) { // 控制--i，遍歷原hash表中的節點
            int nextIndex, nextBound;
            if (--i >= bound || finishing)
                advance = false;
            else if ((nextIndex = transferIndex) <= 0) {
                i = -1;
                advance = false;
           }//TRANSFERINDEX 即用CAS計算得到的transferIndex
            else if (U.compareAndSwapInt
                     (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); //擴容閥值設為原來的1.5倍，即現在的0.75倍
                return; // 僅有的2個跳出死迴圈出口之一
            }//CAS更新擴容閾值,sc-1表明新加入一個執行緒參與擴容
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;// 僅有的2個跳出死迴圈出口之一
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
       else if ((f = tabAt(tab, i)) == null) //該節點為空，則插入ForwardingNode
            advance = casTabAt(tab, i, null, fwd);
        //遍歷到ForwardingNode節點，說明此節點被處理過了，直接跳過。這是控制併發擴容的核心 
       else if ((fh = f.hash) == MOVED) // MOVED=-1，hash for fwd
            advance = true; // already processed
       else {
            synchronized (f) { //上鎖
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn; //ln原位置節點，hn新位置節點
                    if (fh >= 0) { // 連結串列
                        int runBit = fh & n; // f.hash & n
                        Node<K,V> lastRun = f; // lastRun和p兩個連結串列，逆序？？
                        for (Node<K,V> p = f.next; p != null; p = p.next) {
                            int b = p.hash & n; // f.next.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) // 和HashMap確定擴容後的節點位置一樣
                                ln = new Node<K,V>(ph, pk, pv, ln);
                            else
                                hn = new Node<K,V>(ph, pk, pv, hn); //新位置節點
                        }//類似HashMap，為何i+n？參見HashMap的筆記
                        setTabAt(nextTab, i, ln);//在nextTable[i]插入原節點
                        setTabAt(nextTab, i + n, hn);//在nextTable[i+n]插入新節點
                        //在nextTable[i]插入forwardNode節點，表示已經處理過該節點 
                        setTabAt(tab, i, fwd);
                        //設定advance為true 返回到上面的while迴圈中 就可以執行--i操作
                        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;
                        //lc、hc=0兩計數器分別++記錄原、新bin中TreeNode數量
                        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;
                            }
                        }//擴容後樹節點個數若<=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;
                    }
                }
            }
        }
    }
}