ConcurrentHashMap的扩容

ConcurrentHashMap（以下简称CHM）扩容的实现非常精妙，可以说是CHM的精髓所在。它可以在不启用额外线程的情况下，借用已有的线程实现快速扩容，同时还可以保证线程安全。下面我们不妨带着下面这几个问题一块儿来看看CHM的源码。

1. 什么时候触发扩容
2. 扩容时如何保证线程安全
3. 如何利用多线程扩容
4. 线程间如何协作

不过在看代码之前，这几个问题最好还是先从概念的角度搞清楚。以便我们能更好的理解它的设计。

什么时候触发扩容

CHM添加数据时，如果成功，最终会调用addCount。如果添加数据的过程中发现有hash冲突，则会触发扩容检查。如果此时CHM中容纳的元素的数量超过了table长度的0.75，则会触发扩容。
而在CHM的操作过程中，如果发现正在扩容（目标bin的hash被标志为MOVED），则当前线程也会参与扩容。

【注意】CHM的size()计算也比较有特色。并没有设置一个专门的用以计数的属性。可以参考我的另外一篇博文ConcurrentHashMap源码分析之计数：addCount、fullAddCount、size

扩容时如何保证线程安全

CHM保证线程安全的方式包括：

• volatile数据：transerIndex声明为volatile
• CAS操作：transferIndex -= stride
• synchronized锁：迁移时对当前bin加锁

如何利用多线程扩容

• CHM根据核数切分扩容任务
• 每线程负责的bin的数目为（stride），最小为16
• 参与扩容的线程，按批次处理扩容，直至所有的bin都已从table迁移到nextTable
• 访问CHM的线程如果发现正在扩容，则转而参与扩容

线程间如何协作

• CHM的transferIndex属性记录当前尚未分配的待转移的bin的下标
• 参与扩容的线程通过CAS操作修改transferIndex(即tranfserIndex-stride)，从而竞争该批次的处理权
• 竞争获胜者，以(transferIndex - stride, transferIndex) 这个双开区间作为自己的处理范围
• 竞争失败者，继续竞争下一批数据的处理权，直至竞争成功，或所有数据都已经迁移完毕
• 竞争获胜者，通过synchronized对当前bin加锁，以避免被其他写操作影响

扩容源码分析

helpTransfer

如果正在访问的bin已经迁移了，则CHM会调用helpTransfer，参与扩容。

// f是正在被访问的bin节点
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
    Node<K,V>[] nextTab; int sc;
    // 如果节点已经迁移，则bin会被替换为ForwadingNode，同时其Hash被置为MOVED
    if (tab != null && (f instanceof ForwardingNode) &&
        (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
        int rs = resizeStamp(tab.length);
        while (nextTab == nextTable && table == tab &&
               (sc = sizeCtl) < 0) {
            // sc右移16位如果不等于rs，则说明上一次的扩容已经完毕
            // 至于sc == rs + 1，其实是个bug。参考JDK12，应该是(sc >>> RESIZE_STAMP_SHIFT) == rs + 1。
            // 但由于前面的条件，所以永远不会命中
            // transferIndex是从n开始递减，所以如果它<=0，则表示所有要迁移的bin都已经分配到各个线程
            if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                sc == rs + MAX_RESIZERS || transferIndex <= 0)
                break;
			// sc + 1，表示增加一个参与扩容的线程
            if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                transfer(tab, nextTab);
                break;
            }
        }
        return nextTab;
    }
    return table;
}

transfer

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        // 按核数计算每个扩容线程承担的bin数
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        // 如果目标table还没有准备好，则创建
        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的起始值是从高位开始
            transferIndex = n;
        }
        int nextn = nextTab.length;
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        // advance=true，表示当前bin（下标为i）已经完成迁移，寻找下一个待处理的bin
        // advance=false，表示当前bin（下标为i）需要迁移
        boolean advance = true;
        boolean finishing = false; // to ensure sweep before committing nextTab
        // i是待处理bin的下标，bound是当前stride区间的下限（包含）
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            // 寻找待迁移的bin的下标
            while (advance) {
                int nextIndex, nextBound;
                // bound是--i的下限，即下一个处理区间的上限
                if (--i >= bound || finishing)
                    advance = false;
                // 如果transferIndex<=0，表明迁移已经完成
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                // CAS设置下一个待扩容区间的上限（transferIndex）
                // 如果设置成功，则开始处理下一个区间
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    // bound是--i的下限(包含)，即下一个处理区间的上限（不包含）                
                    bound = nextBound;
                    // 下一个待处理区间的第一个bin的下标
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            // i<0表示本轮扩容已经完毕。参考上面的while循环
            // i >=n || i+n>-=nextn，表示别的线程干活比较快，或当前线程持续停顿过久，导致transferIndex已经是下一轮扩容中的值。参考上面的while循环
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                if (finishing) {
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    // 参考addCount，触发扩容时（首个参与扩容的线程）的sizeCtl的设置，即扩容戳左移16位+2
                    // 以后每增加一个扩容线程，sizeCtl就会加1， 
                    // 每完成一个线程，sizeCtl就会减1。正如上面if条件中的表达式
                    // 下面这个判断，如果不等，说明还有线程没有完成工作
                    // 如果相等，说明所有线程都完成工作了
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    // 所有扩容线程都完成工作了，开始收尾工作（finishing=true）
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            // 如果当前bin为空，则设置为ForwardingNode
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            // 当前bin已经迁移了，继续处理下一个bin
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
                synchronized (f) {
                	// 迁移主要操作，就是要算出每个Node在nextTable中的下标
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        // 对于链表（一个节点的bin可以看作是特殊链表），新下标的值就看runBit（看下面的解释）
                        if (fh >= 0) {
                            // n是2的幂，所以runBit要么为n，要么为0
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            // 找到最后一个runBit跟链头不一样的Node
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                if (b != runBit) {
                                    // 保证runBit的含义跟lastRun一致，也就是lastRun是最后一个runBit为0，或为1的Node
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            // 如果runBit=0， 则lastRun之前的节点的新下标就是i；ln为低位链
                            // 如果runBit=1，则lastRun之前的新下标是n+i；hn为高位链
                            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;
                                // 将链中的节点，根据runBit分别放置到低位链和高位链
                                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);
                            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);
                                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;
                        }
                    }
                }
            }
        }
    }

如何计算节点在nextTable中下标

虽然可以通过Node的hashCode跟nextTable的长度取模，即按位与h&(2n-1)，其中n为当前table的长度。但是CHM采用了更高效的方式，即用runBit划分高低链（hn，ln）。

• runBit = 0的为低链
• runBit = 1的为高链

runBit的算法为：h & n。由于n为2的幂，所以比较table和nextTable的和下标，即h&(n-1)和h&(2n-1)，即可发现区别仅在h的第n位是否为1，即runbit=n还是=0。如果为n，则新下标为n+i，如果为0，则新下标为i（等于原下标）。

所以可以根据runBit将链表中的元素划分到低链和高链，然后将链头设置到对应bin即可。