ConcurrentHashMap扩容源码详细分析

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    //获取步长 就是每个线程需要处理的桶数量
    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
            //如果移位异常 就将容量改为int的最大值
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        nextTable = nextTab;
        //新表的索引
        transferIndex = n;
    }
    //获取新表的容量
    int nextn = nextTab.length;
    //fwd对象作为占位符 表示是否移动过
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    //表示可以往下一个hash桶遍历
    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;
            //如果当前扩容的下标还没有超出步长 则不跳过 直接退出while 去处理这个桶
            //这边用--代表的是从尾开始往前遍历 就是从边界的右边向左边进行hash桶的处理
            if (--i >= bound || finishing)
                advance = false;
            //能执行到这里说明已经超出该线程走的步长了 所以这时候需要去判断是否全部的哈希桶都完成了扩容
            //同时给nextIndex赋值 判断如果<=0 就说明所有的区间都已经有人在处理了或者是已经完成了处理
            else if ((nextIndex = transferIndex) <= 0) {
                //这边标记为-1给后面的if(i<0)作判断用
                i = -1;
                //既然所有的区间都有人处理 所以也不需要再去遍历下一个哈希桶了
                advance = false;
            }
            //执行到这里表示该线程完成了当前的任务 而且还有别的区间的哈希桶未扩容 这时候可以分配新的区间的扩容给该线程
            else if (U.compareAndSwapInt
                     (this, TRANSFERINDEX, nextIndex,
                      nextBound = (nextIndex > stride ?
                                   nextIndex - stride : 0))) {
                //上面用cas的方式去处理需要扩容的下标
                //代表区间的最前下标
                bound = nextBound;
                //代表区间的最后下标
                i = nextIndex - 1;
                advance = false;
            }
        }
        //这里后面两个判断好像用不着 i<0这是再前面让i赋值i=-1的时候执行的
        if (i < 0 || i >= n || i + n >= nextn) {
            // sc的表示的是当前有多少个线程正在执行扩容的线程数量
            int sc;
            
            //sizeCtl有两个作用 在还没完成扩容前 这个sizeCtl代表的是正在执行扩容的线程数量
            //扩容完成后代表的是新容器的扩容阈值 0.75*size
            if (finishing) {
                //如果所有线程都完成了扩容 就更新该concurrentHashMap中的属性
                nextTable = null;
                table = nextTab;
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }
            //这里是所有区间都有线程处理 因此自己就不需要处理 所以用cas的方式将处理的线程-1
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                //这里如果判断他不相等说明还有在扩容的线程
                //为什么可以这么判断？
                //扩容的第一次发生是在putval中的最后addCount方法 当判断size到达阈值的时候触发扩容 
                //然后在调用这个扩容前 有一行
                //U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2)
                //因此在这边跟前面进行首位呼应 如果相等说明所有都桶都处理完了
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                //让i=n 重新去遍历一遍哈希桶看还有没有未扩容的 
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
        else if ((f = tabAt(tab, i)) == null)
            //如果这个位置的哈希桶为空，用fwd对象作为占位符
            advance = casTabAt(tab, i, null, fwd);
        else if ((fh = f.hash) == MOVED)
            //如果这个位置的哈希桶为moved 就是代表以及处理过的 则让advance为true 以便上面while中去处理下一个桶
            advance = true; // already processed
        else {
            //这边就是开始进行迁移了
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    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;
                        }
                        //去构造两条链表，如果当前有效位最高位的hash&0 = 0的话就加入ln链表中，否则加入hn链表中。
                        for (Node<K,V> p = f; p != lastRun; p = p.next) {
                            int ph = p.hash; K pk = p.key; V pv = p.val;
                            //这边跟HashMap不同 这里我们可以看到他是new Node 然后去将hash、下个节点等节点信息赋值进去,
                            //因此他地址其实是改变的。而HashMap的做法却是直接通过引用去做的。因为确认Hash桶是根据Node中的字段hash，而不是根据地址来的。
                            if ((ph & n) == 0)
                                ln = new Node<K,V>(ph, pk, pv, ln);
                            else
                                hn = new Node<K,V>(ph, pk, pv, hn);
                        }
                        //构建完两个链表 就将他放入新的桶中，比如这时候在处理第2个桶 就是i=2，这次扩容是从32->64 这里的n就是32，因此ln就放在第二个桶，hn就放在第34个桶.
                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        //以fwd占位符代替旧的表 表示该桶已经处理过
                        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;
                        //跟上面一样 去构造两条链表 但是不同的是 上面的链表是以Node类型的，这里的两条链表是以TreeNode类型的。
                        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那就转换成Node类型的链表，否则就去创建红黑树，再放入指定的新哈希桶中
                        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;
                    }
                }
            }
        }
    }
}