[TOC]

流程图

ConcurrenthashMap 的 transfer 主要是用于扩容重组阶段，当内部数组的容量值超过阈值时，将触发扩容重组， transfer 是该过程的主要实现。

相关概念

1. ConcurrentHashMap 中，使用一个字段复用了多种功能，如：阈值控制、内部 Node[] 数组状态控制、扩容线程控制 等，该字段就是 sizeCtl。

/*** 默认为0，用来控制table的初始化和扩容操作* -1: 代表table正在初始化* -N: 取-N对应的二进制的低16位数值为 M=(sizeCtl&31)，此时有M-1个线程进行扩容* * 其余情况：* 1、如果table未初始化，表示table需要初始化的大小。* 2、如果table初始化完成，表示table的容量，默认是table大小的0.75倍*/private transient volatile int sizeCtl;

2. ConcurrentHashMap 在重组时，做法与 HashMap 类似，但是具体新的数组，则是使用了内部一个数组变量 nextTable 以保证并发控制。其他如：链表的重组、树结构的重组 流程均是大同小异。
3. ConcurrentHashMap 的重组采用了跟分段表类似的思想，实际上是将数组划分为不同的分段区间，如果有线程进入，可获取该区间辅助转换。
4. transferIndex 是 ConcurrentHashMap 的内部属性，主要是在重组阶段中使用，用来表示还未被转换的数组，区间为：table[0] ~ table[transferIndex-1]
5. ConcurrentHashMap 并发转换的过程，借助了 信号量 的概念，只有获取到信号的线程，才能进入辅助转换，而 信号量 则存储在 sizeCtl，每当一个线程进入获取，则 sizeCtl + 1（首个线程开启转换则是 sizeCtl + 2）。主要注意的是，该信号量的初始值为 负数，加入线程将增大 sizeCtl，直到 sizeCtl 的增大达到 0 时，信号量将用完，默认的与 信号量 相加等于 0 的值是：65534，也就是说，最多允许 65534 条线程参与辅助转换（非固定，可调节）。所以可通过 rs + 1 ~ rs + 65534 的边界控制，来决定线程是否加入辅助转换。让 sizeCtl 成为负数变成信号量的主要代码是： resizeStamp(n) << RESIZE_STAMP_SHIFT
6. ConcurrentHash 的转换过程中，用到的辅助属性有两个：nextTable，transferIndex，它们属于线程共享的，所以在对他们进行变更时，都是使用了 “自旋/死循环 + CAS” 的方式，实现线程并发安全。

解析

转换过程 transfer 的每个调用入口，实际上外部都有对 sizeCtl 进行 自旋 + CAS 的操作。也就是并发情况下，即使多条线程想要进行扩容，那也只有一条线程能够成功，另外的线程则进入辅助扩容的过程

addCount

扩容方法进入前的判断如下：

private final void addCount(long x, int check) {// 省略部分代码...// nt -> nextTable// n -> num，sc -> sizeCtlNode[] tab, nt;int n, sc;// 当前存储大于 75%，且总大小小于最大容量，需要扩容while (s >= (long) (sc = sizeCtl) && (tab = table) != null && (n = tab.length) < MAXIMUM_CAPACITY) {// resizeStamp 纯粹只是移位来保证右 16 位为0，可用来控制作为线程最大数// 左 16 位实际并没有保留太多信息（因为明显：resizeStamp(4)、resizeStamp(5)、resizeStamp(6)、(7)// 是相同的结果int rs = resizeStamp(n) << RESIZE_STAMP_SHIFT;if (sc < 0) {// 限制线程的最大或最小，当达到最大 65534（默认） 或 1 条时，则直接跳出// rs + 1 --> 最少线程数（相当于不正确的情况了，或者是初始化，因为起始时最少是 rs + 2）// rs + MAX_RESIZERS --> 最多线程数// 或其他情况，则不再辅助转移，如：nextable 已为 null 或 transferIndex <= 0（说明已结束）// 前两个条件是限制线程数，后两个条件是扩容已经结束if (sc == rs + MAX_RESIZERS || sc == rs + 1 || (nt = nextTable) == null || transferIndex <= 0)break;if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1))transfer(tab, nt);}// 如果 sc >= 0，说明是刚开始，// 因为 sc < 0 时，低16位表示有多少条线程在进行转移：sizeCtl & 31 - 1// 所以这里要 rs + 2else if (U.compareAndSetInt(this, SIZECTL, sc, rs + 2))transfer(tab, null);s = sumCount();}
}

这里出现大量的判断比较，容易造成混乱，但主要记住：这些判断比较，在 ConcurrentHashMap 大部分是边界判断。记住这点后能够帮助理解大部分的判断比较，比如：sc == rs + MAX_RESIZERS 和 sc == rs + 1实际上是对线程数的上下界的限制，超过限制，则不进入辅助转换。

transfer

ConcurrentHashMap 是分段进行并发转换，就是一个数组，按 幅度 划分，然后相应的线程获取到哪个分组，则负责该分组的转换的完成。那么重组转换的出口在哪里呢？只有当所有线程都执行完毕，处理转换的线程的信号量没有被获取了 ，才退出整个转换过程。默认最小幅度是 16，也就是说线程的最少处理元素个数是 16 个。

private final void transfer(Node[] tab, Node[] nextTab) {// stride 幅度int n = tab.length, stride;// 如果 CPU 大于 1，控制最少每个线程的处理量为 16 ==> n / 8 / NCPUif ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)stride = MIN_TRANSFER_STRIDE; // subdivide rangeif (nextTab == null) {            // initiatingtry {// 数组翻倍，为什么要多出一个赋值操作？是因为 new 操作可能异常？貌似也不影响@SuppressWarnings("unchecked")Node[] nt = (Node[])new Node[n << 1];nextTab = nt;} catch (Throwable ex) {      // try to cope with OOME// 失败，直接增加数组大小，退出sizeCtl = Integer.MAX_VALUE;return;}// 因为本方法的外层调用都使用了 CAS，所以可以保证此赋值的正确性（多线程情况下）nextTable = nextTab;// table 大小，最开始的转换范围是原数组大小transferIndex = n;}//...}

进入转换方法后，首先就是确定线程处理幅度，然后初始化 nextTable （如果需要的话），并初始化转换过程中需要用到的一些辅助属性，如：transferIndex = n = table.length。

接下来，就是一个死循环（假象）。死循环内嵌死循环。第一个死循环使用到了局部参数 i 和 bound，实际上，在每个线程进入该方法后，都会获得自己这两个局部变量值，而它们的值变动则是在内部循环中开始赋值，一旦赋值成功，那么第一个死循环就变成了一个有界的 for 循环

优先看第二个内部循环， advance 变量控制了该循环。advance 变量主要表示：是否推进到下一个元素。它实际与 i 和 bound是有逻辑关系的，一旦 i 和 bound的关系不匹配，那么 advance 也就必须为 false，不再让线程进行推进，推进的操作是（ --i ）。也就是说，线程进入后，将有三个变量控制其运行，其中 bound, i是线程处理的数组边界，而 advance 则控制线程在这个边界中进行移动

private final void transfer(Node[] tab, Node[] nextTab) {// ... 省略部分代码int nextn = nextTab.length;ForwardingNode fwd = new ForwardingNode(nextTab);// 是否推进到下一个元素，false 则表示还是处理当前元素boolean advance = true;boolean finishing = false; // to ensure sweep before committing nextTabfor (int i = 0, bound = 0;;) {// f -> findNode；fh -> findNode hashNode f; int fh;// 死循环主要是为了划分线程处理区间 ！还有控制元素推进while (advance) {int nextIndex, nextBound;// 死循环标志位，不断死循环执行处理，没有太多意义，纯粹依靠标志位// 每一个线程进来，第一个判断都不成立// 通过 --i 来控制线程处理区间的推进，// 如果 --i > bound 说明区间范围超过线程的处理范围，线程不再该范围内就行推进，标志位为false// 每一次划分完，则 i 实际上是闭区间的尾部，而 bound 则为区间的首部，所以 --i 成功，进入区间下一个元素处理if (--i >= bound || finishing)advance = false;else if ((nextIndex = transferIndex) <= 0) {// 赋值 nextIndex// 小于0 ：表已被划分完，不再作划分推进，跳出循环i = -1;advance = false;}else if (U.compareAndSetInt(this, TRANSFERINDEX, nextIndex,nextBound = (nextIndex > stride ?nextIndex - stride : 0))) {// CAS 替换值，将 transferIndex 更新为 transferIndex - stride// 控制此线程的处理区间为：bound ~ (nextIndex - 1)// 假定初始表大小为 35，2个线程进入（其实跟线程数无关，跟 CPU 有关），NCPU = 2 ，则幅度控制下为 16// 通过循环，划分下为：// 19 ~ 34// 3 ~ 18// 0 ~ 2// 也就说，transfer 的处理，（单线程）是从尾部到头部（当然总体情况下多线程则取决于线程的执行情况）bound = nextBound;i = nextIndex - 1;advance = false;}}// ... 省略部分代码
}

可以看到，内部死循环的主要作用，其实是为了划分分区（划分幅度为 stride），也可以意识到，即使是单线程，其执行也是按分区执行，并且执行的分区顺序是从尾部到首部。通过 CAS 保证分区的划分的线程安全，失败则重新循环再次操作。

划分完分区后，剩下的就是线程的处理过程。处理过程包括 2 部分，一部分是普通的元素处理，一部分是边界控制——退出出口。

在每一个元素的处理过程中，线程都会先判断是否到达出口，是则退出？差不离，但退出包含两种情况，一种是普通的辅助线程的退出，它只擦自己的屁股，另外一种是整体线程的退出，它除了处理负责自己的退出出口，还要负责将重组后的结果 nextTable 重复赋值给 table，并为 sizeCtl 赋值为新数组大小的 0.75 倍的阈值

private final void transfer(Node[] tab, Node[] nextTab) {// ... 省略部分代码// 如果 i < 0 || i >= n || i + n >= nextn ，都属于区间的边界判断// 超过边界则判断是否线程都已执行完毕，其实只有首尾区间的线程会触发到这个判断，// 其他的线程因为 stride < i < 2stride，所以不会触发此判断if (i < 0 || i >= n || i + n >= nextn) {int sc;// 扩容出口// 只有当 finishing 为 true 时，才真正将 nextTable 赋值给 旧 table 指针// 而 finishing 为 true 的唯一条件，是所有的线程都执行完毕if (finishing) {nextTable = null;table = nextTab;// 翻倍减去 0.25 ，为新数组大小的 0.75 倍的阈值sizeCtl = (n << 1) - (n >>> 1);return;}if (U.compareAndSetInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)return;// 只有当所有的线程都执行完毕，才能保证 finishing 为 truefinishing = advance = true;i = n; // recheck before commit}}     // ... 省略部分代码
}

说完了边界出口，剩下的就是普通的操作了，有以下判断：

• 当线程转换时旧数组对应位置上为 null，则直接 CAS 替换为 ForwardingNode（其hash = MOVED），表示转移过了；此时，当外部有操作 put 刚好命中此位置时，将会进入辅助转换的过程，判断依据就是 if (hash == MOVED)。也就是说，在重组转换过程中，进行 put 操作，将进入辅助转换过程。
• 如果 hash 为 MOVED，则表示该位置已被其他线程转移过，推进到下一个元素

最后，进入与 HashMap 相同的链表重组和树结构重组的逻辑中，成功执行后，advance = true，继续推进处理元素（--i）。这里比 HashMap 多出一步，就是将旧数组对应位置上的标记为已处理。

private final void transfer(Node[] tab, Node[] nextTab) {// ... 省略部分代码else if ((f = tabAt(tab, i)) == null)advance = casTabAt(tab, i, null, fwd);　　　// 如果旧表该位置为null，则标记为已处理else if ((fh = f.hash) == MOVED)         // 感觉不太可能遇到，毕竟线程单一负责自己的区域（？）advance = true; // already processedelse {// 进入转换synchronized (f) {if (tabAt(tab, i) == f) {Node ln, hn;// 普通链表的 hash 节点是正常的 hash 码，树节点的 hash 则默认小于 0// 重哈希算法与 HashMap 相同，都是以 2的n次幂 对应的二进制刚好为 1，// 直接移动高位部分元素if (fh >= 0) {// ... 省略部分代码}else if (f instanceof TreeBin) {// ... 省略部分代码 setTabAt(nextTab, i, ln);setTabAt(nextTab, i + n, hn);// 处理完成后，将旧数组的节点标记为已处理（旧数据将没有数据）setTabAt(tab, i, fwd); advance = true;}}}}
}

至此，整个 ConcurrentHashMap 的转换过程算完了