ConcurrentHashMap的扩容方法transfer源码详解

主要细节问题：

1. 什么时候触发扩容？扩容阈值是多少？
2. 扩容时的线程安全怎么做的？
3. 其他线程怎么感知到扩容状态，从而一起进行扩容？
4. 多个线程一起扩容时，怎么拆分任务，是不是任务粒度越小越好？
5. ConcurrentHashMap.get(key)方法是没有加锁的，怎么保证在这个扩容过程中，其他线程的get(key)方法能获取到正确的值，不出现线程安全问题？

魔鬼在细节里，一起看下源码，然后回答下上面的细节问题，先看下触发扩容的代码，在往map中put新数据后会调用这个addCount(long x, int check)方法，计算当前map的容量，当容量达到扩容阈值时会触发扩容逻辑。

触发扩容源码：

private final void addCount(long x, int check) {
   
        // 借用Longadder的设计思路来统计map的当前容量，减少锁竞争，详细见下面的分析
        CounterCell[] as; long b, s;
        if ((as = counterCells) != null ||
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
   
            CounterCell a; long v; int m;
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                !(uncontended =
                  U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
   
                fullAddCount(x, uncontended);
                return;
            }
            if (check <= 1)
                return;
            s = sumCount();
        }
        if (check >= 0) {
   
            Node<K,V>[] tab, nt; int n, sc;
            // s是当前的容量，sizeCtl是扩容阈值，当当前容量大于扩容阈值时，触发扩容，在扩容逻辑被触发前sizeCtl是正数，表示的下次触发扩容的阈值，
            // 而在进入扩容逻辑后，sizeCtl会变成负数，并且sizeCtl是32位的int类型，高16位是扩容的邮戳，低16位是同时进行扩容时的线程数，在某个线程进入扩容时会修改sizeCtl值，在下面的代码里能看到这个修改逻辑
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                   (n = tab.length) < MAXIMUM_CAPACITY) {
   
                // 生成当前扩容流程邮戳，n是当前数组的长度，当n相同时，邮戳肯定也是一样的，计算逻辑详见下面分析1
                int rs = resizeStamp(n);
                // sc小于0 标识已经在扩容中，因为在触发扩容时会通过CAS修改sc这个值
                // sc值是int类型，32位，低16位记录了当前进行扩容的线程数，高16位就是邮戳，这个逻辑见下面分析2
                if (sc < 0) {
   
                // (sc >>> RESIZE_STAMP_SHIFT) != rs 说明不是同一个扩容流程，放弃扩容
                // sc == rs + 1 || sc == rs + MAX_RESIZERS 这个条件是个bug，应该写成(sc >>> RESIZE_STAMP_SHIFT) == rs + 1 ||  (sc >>> RESIZE_STAMP_SHIFT) == rs + MAX_RESIZERS
                // 在jdk12中已被修复，oracle官网修复链接是 https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8214427
                // (nt = nextTable) == null  有线程去扩容时，必然会生成nextTable，所以这里不需要处理
                // transferIndex <= 0 transferIndex是标记当前还未迁移的桶的下标，如果小于等于0，则表示已经迁移完，不需要做处理
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                        break;
                // 在进入扩容流程后会将sizeCtl值+1，sizeCtl的低16位表示当前并发扩容的线程数        
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                        transfer(tab, nt);
                }
                // sc大于0 则表示没有进入扩容逻辑，则通过CAS将sizeCtl值修改成 (rs << RESIZE_STAMP_SHIFT) + 2
                // 这里的rs就是上面生成的扩容邮戳，这里会将rs向左位移16位，这样低16位用来记录并发扩容的线程数，高16位用来表示扩容邮戳，至于为什么要+2，我也没有理解...
                else if