concurrentHashMap扩容相关方法详解
上一个博客中说到了concurrentHashMap的put操作，在put操作之后如果添加了节点，我们首先会把全局的节点数+1,如果满足了扩容条件，我们则进行扩容
我们先从addCount方法说起
/**
* 主要有2个功能，计数和扩容想关操作，
* x：我们需要增加的值
* check：
* 如果check<0 我们不进行扩容工作，
* 如果check<1, 我们只在没有发生计数竞争（当前的cell数组没有被创建）的情况下进行扩容工作
* 这边的计数逻辑和LongAddr的计数逻辑相同，主要是使用一个base和一个cell的数组，总数等于base中的数+cell数组中所有数之和
* 另外值得注意的是，当计数竞争很激烈，使用到了fullAddCount方法时，也不会进行扩容相关工作
*/
private final void addCount(long x, int check) {
//as 表示 LongAdder.cells
//b 表示LongAdder.base
//s 表示当前map.table中元素的数量
CounterCell[] as; long b, s;
//条件一：true->表示cells已经初始化了，当前线程应该去使用hash寻址找到合适的cell 去累加数据
// false->表示当前线程应该将数据累加到 base
//条件二：false->表示写base成功，数据累加到base中了，当前竞争不激烈，不需要创建cells
// true->表示写base失败，与其他线程在base上发生了竞争，当前线程应该去尝试创建cells。
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
//true -> 未竞争 false->发生竞争
boolean uncontended = true;
//条件一：as == null || (m = as.length - 1) < 0
//true-> 表示当前线程是通过 写base竞争失败 然后进入的if块，就需要调用fullAddCount方法去扩容 或者 重试
//条件二：a = as[ThreadLocalRandom.getProbe() & m]) == null 前置条件：cells已经初始化了
//true->表示当前线程命中的cell表格是个空，需要当前线程进入fullAddCount方法去初始化 cell，放入当前位置.
//条件三：!(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)
// false->取反得到false，表示当前线程使用cas方式更新当前命中的cell成功
// true->取反得到true,表示当前线程使用cas方式更新当前命中的cell失败，需要进入fullAddCount进行重试 或者 扩容 cells。
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;
}
//插入的时候，check = 0 表示头节点就是插入的元素 check等于1表示插入位置为头结点以后的位置
if (check <= 1)
return;
//计数，多线程下只是一个估值
s = sumCount();
}
//check>=0 表示当前为put操作，remove操作的check值为负数
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
//自旋
//条件一：s >= (long)(sc = sizeCtl)
// true-> 1.当前sizeCtl为一个负数 表示正在扩容中..
// 2.当前sizeCtl是一个正数，表示扩容阈值
// false-> 表示当前table尚未达到扩容条件
//条件二：(tab = table) != null
// 恒成立 true
//条件三：(n = tab.length) < MAXIMUM_CAPACITY
// true->当前table长度小于最大值限制，则可以进行扩容。
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
//获得此次的一个扩容唯一表示戳
//计算方法 Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
int rs = resizeStamp(n);
//表示正在扩容中，尝试帮助其他线程进行扩容
if (sc < 0) {
//条件一：(sc >>> RESIZE_STAMP_SHIFT) != rs
// true->说明当前线程获取到的扩容唯一标识戳 非 本批次扩容
// false->说明当前线程获取到的扩容唯一标识戳 是 本批次扩容
//条件二： JDK1.8 中有bug jira已经提出来了 其实想表达的是 = sc == (rs << 16 ) + 1
// true-> 表示扩容完毕，当前线程不需要再参与进来了
// false->扩容还在进行中，当前线程可以参与
//条件三：JDK1.8 中有bug jira已经提出来了 其实想表达的是 = sc == (rs<<16) + MAX_RESIZERS
// true-> 表示当前参与并发扩容的线程达到了最大值 65535 - 1
// false->表示当前线程可以参与进来
//条件四：(nt = nextTable) == null
// true->表示本次扩容结束
// false->扩容正在进行中
//条件五：true 表示当前没有剩余任务
// false 表示当前还有剩余任务
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
//cas修改sizeCtl为sizeCtl+1，说明增加了一个线程进行扩容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
//真正扩容的逻辑
transfer(tab, nt);
}
//1000 0000 0001 1011 0000 0000 0000 0000 +2 => 1000 0000 0001 1011 0000 0000 0000 0010
//条件成立，说明当前线程是触发扩容的第一个线程，在transfer方法需要做一些扩容准备工作
//设置sc的高16位为表示搓，低16为当前扩容的线程数+1
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
//更新计数值，看是否还需要进行下一次扩容
s = sumCount();
}
}
}
扩容的核心方法transfer
/**
* Moves and/or copies the nodes in each bin to new table. See
* above for explanation.
*
* 1 计算出工作的最大步长
* 2 如果是第一次扩容
* 创建一个2倍长的表，把他赋值给nextTab
* 更新transferIndex为需要迁移的总长度，即老表的长度
* 3 扩容
* 创建一个fwd节点，并且当前fwd节点的nextTab设置为全局的nextTab
* 自旋
* 3.1 自旋 i(下界) bound(上界) nextIndex nextBound 分配任务是从下往上分配
* 1. 当期任务还没完成或者所有迁移任务都已经完成，现在属于最后的检查阶段
* 2. 当前任务已经完成并且没有新的任务需要完成，设置i = -1
* 3. 当前任务已经完成还有任务可以分配，使用cas分配当前任务，nextIndex = transferIndex nextBound i = nextIndex - 1 bound = nextBound
* 3.2
* 3.2.1 如果当前迁移工作已经完成
* 1. 迁移任务全部完成，第二次进入此函数
* ①nextTable设置为空 ②nextTab的值赋给tab ③设置下次的扩容阀值
* 2. 第一次进入该函数
* cas设置参加的线程数-1
* 2.1 如果不是最后一个线程，则正常退出
* 2.2 如果是最后一个线程，需要重新开始检查，看是否还有遗漏（此时的sizeCtl低16位为1）
* i = n
* 3.2.2
* cas获取头部，如果头部为null
* 表示此节点不需要迁移工作，设置table对应的节点为fwd节点，表示迁移成功
* 3.2.3 如果头部为fwd节点，表示此节点已经完成过迁移工作
* 3.2.4 说明此时是链表或者红黑树类型，并且需要完成迁移工作
* 锁住头结点
* 判断当前锁住的头结点和我们桶的头结点是否相同
* 1、不相同 退出重头开始
* 2、相同
* 2.1 判断当前节点是链表 fh >= 0
* 使用lastRun机制头插法形成2条单链表
* cas 设置nextTable 对应位置
* cas 把当前表的对应位置设置为fwd节点
* 2.2 当前节点是红黑树节点
* 使用尾差法形成2条双向链表
* 判断是否节点数小于6 ，如果小于6 则把双向链表变为单链表 ，如果大于等于6 再判断是否只有一个单链有值，如果是，则利用之前的表
* cas 设置nextTable 对应位置
* cas 把当前表的对应位置设置为fwd节点
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
//计算出每次所需要完成的的步长,单核的话就是tab的长度，表示就只有一个cpu进行工作
// 多核心等于表的长度/8 / cpu核数和16里面的较大值
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
//代表是第一次扩容，要做一些初始化工作
//①初始化nextTable，长度为老表的2倍
//②更新transferIndex的值，此值为剩余的工作的长度
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
//如果发现oom，将sizeCtl的值变为最大值，不进行扩容
sizeCtl = Integer.MAX_VALUE;
return;
}
//nextTable中间表，n表示扩容进度
nextTable = nextTab;
transferIndex = n;
}
//nextn表示新表的长度
int nextn = nextTab.length;
//fwd 节点，当某个桶位数据处理完毕后，将此桶位设置为fwd节点，其它写线程 或读线程看到后，会有不同逻辑。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
//true表示继续推进
boolean advance = true;
//表示是否结束(确保每一个迁移过的节点在迁移之前都变为了fwd节点）
boolean finishing = false; // to ensure sweep before committing nextTab
//i 表示分配给当前线程任务，执行到的桶位
//bound 表示分配给当前线程任务的下界限制
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
/**
* 1.给当前线程分配任务区间
* 2.维护当前线程任务进度（i 表示当前处理的桶位）
* 3.维护map对象全局范围内的进度
*/
while (advance) {
//下一次的开始坐标
//下一次的结束坐标
int nextIndex, nextBound;
//如果当前的任务还没完成，--i让其指向下一个桶位
if (--i >= bound || finishing)
advance = false;
//表示没有多余的任务需要做了
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//CASE3:
//前置条件：1、当前线程需要分配任务区间 2.全局范围内还有桶位尚未迁移
//条件成立：说明给当前线程分配任务成功
//条件失败：说明分配给当前线程失败，应该是和其它线程发生了竞争吧
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
/**
* 最后一个线程有可能会进入这2次，其他线程进入这1次
* 第一次：说明所有的任务已经分配成功
* 如果是最后一个退出线程，则重新进行一次检查工作，如果不是最后一个退出线程，直接退出
* 第二次：所有的任务都已经完成，将nextTable的值设为null，将table更改为新的table，设置新的扩容阀值，返回
*/
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
//所有的任务都已经完成
if (finishing) {
nextTable = null;
table = nextTab;
//sizeCtl 为新表的0.75倍
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//表示不是最后一个
if ((sc - 2) !=