目录
什么是ConcurrentHashMap
ConcurrentHashMap是J.U.C包里面提供的一个线程安全且高效的HashMap。在并发场景中shi使用频率比较高。由于是HashMap的派生类，所以其API和HashMap类似。
ConcurrentHashMap源码分析
JDK1.7和JDK1.8版本的变化
在JDK1.7的实现上，ConcurrentHashMap是一个Segment数组。通过继承ReentrantLock来进行加锁。通过每次锁住一个segment来保证每个segment内操作的线程安全行从而实现全局的线程安全。
相比于JDK1.7版本，JDK1.8主要有两个改进。
1.取消了segment分段设计，直接使用Node数组来保存数据。并且采用Node数组元素作为锁来实现每一行数据进行加锁来进一步减少并发冲突的概率。
2.将原本数组+单向链表的数据结构变更为了数组+单向链表+红黑树的数据结构。
为什么要引入红黑树？
理想情况下，key hash能够均匀的分散在数组中，那么数组中每个队列的长度主要为0或1.实际情况下，会存在一些队列过长的情况。如果还采用单向链表方式，那么查询某个节点的时间复杂度就变为0(n)；因此对于队列长度超过8的链表，JDK1.8采用红黑树红黑树的结构，查询复杂度为o(logN)。提高了查询性能。（这个结构与HashMap的实现结构基本一致）
从put方法切入
调用ConcurrentHashMap的put方法-自旋操作插入数据（解决并发场景）判断逻辑为
第一个if判断主要对数组进行初始化。
第二个if判断：通过元素的hash值，得到数组对应的位置下标，读取目标位置中的元素，如果为空则通过cas操作进行数据插入。插入成功，跳出循环。
第三个if判断：判断是否需要扩容 MOVED：扩容标识
第四块else代码块：当数组已经被初始化，且当前位置有数据，并且还不需要扩容的情况下。这个时候会在当前位置追加元素，形成链表。这里有synchronized块，锁对象是当前位置的头节点。保证了并发安全。
注意点：多个线程同时进入第二个if判断的时候，假如有线程A成功执行casTabAt操作后。其它线程可以立即看到table[i]的变化。原因：casTabAt方法具有与volatile读写相同的内存语义，根据volatile的happens-before原则：线程A的casTabAt操作对其它线程可见。
总结
1.ConcurrentHashMap向数组内插入数据并未采用加锁的方式。当ConcurrentHashMap调用put方法插入数据的时候，会首先采用volatile读的方式，读取目标数组位置的元素，以保证每次读取到的值都是最新的。如果读取到的元素为空，则通过cas操作将新的值封装成node插入。
2.ConcurrentHashMap向某个数组位置的链表插入数据的时候，会对该位置的头节点进行加锁，锁的粒度更细。同时不影响数组中其它位置数据的插入。这就保证了在单个节点链表上的数据增加是线程安全的。其它节点同时也可以并发插入数据。体现了分布式思想，达到了性能上的提升。
注意点：当链表的长度大于等于8时，会判断是否将链表转化为红黑树。所以，在同步代码块逻辑中会有判断是否将数据插入到红黑树的逻辑。
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 计算hash值
int hash = spread(key.hashCode());
// 用来记录链表的长度
int binCount = 0;
// 自旋操作，当出现线程竞争时不断自旋
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 如果数组为空则对数组进行初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 通过hash值对应的数组下标得到第一个节点；以volatile读的方式来读取table数组中的元素
// 保证每次拿到的数据都是最新的
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果下标返回的节点为空，则通过cas操作将新的值封装成node插入即可，如果cas失败，说明存在竞争，则进入下一次循环
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
// 跳过前几个判断，代码执行到此处，表示当前下标已经有元素了
V oldVal = null;
// 对锁的头节点进行加锁
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// 当链表长度 大于等于 8 之后 判断是否进行链转红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}put方法-初始化数组 initTable()
初始化数组方法中，有一个属性值 sizeCtrl 该属性值有三个作用
1.当该属性值等于 -1 即小于零，表示当前有线程正在对数组进行初始化或者扩容
2.当该属性值大于0的时候，用于去判断下一次是否需要扩容。
3.为负数且不是-1的时候，用来去判断有多少个线程正在扩容（-2 有一个线程正在扩容，以此类推）
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// 这里判断 sizeCtl的值是否小于零
// 如果小于零则表示当前已有线程抢占了初始化操作，直接让出自己的CPU时间片
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// cas操作，去改变 SIZECTL的值替换为-1，表示当前线程抢占到了初始化资格
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
// DEFAULT_CAPACITY 默认初始化容量为16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
// 初始化数组，长度为16，或者初始化在构造ConcurrentHashMap的时候传入的长度
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
// 将初始化完成的数组赋值给 table
table = tab = nt;
// 计算当前容量的0.75倍
sc = n - (n >>> 2);
}
} finally {
// 设置 sizeCtl 为 sc 如果默认16，这个时候 sc = 12
// 即当前容量的0.75倍
sizeCtl = sc;
}
break;
}
}
return tab;
}put方法 - tabAt
tabAt方法本质上就是去获取tab[i]的值。通过getObjectVolatile方法去获取。而不是直接tab[i]的方式获取。
原因：tabAt方法是支持在并发场景中使用的代码。getObjectVolatile方法的保证了可见性，通过Unsafe类对tab进行操作同时又保证了性能。
总结：以volatile读的形式去读取tab[i]的值。若为空，则通过cas操作把新的数据封装成为node节点插入到数组中去。cas操作保证了数据的更新对volatile读可见，从而保证了并发场景下的线程安全。
扩展-偏移地址：偏移地址应用在数组中，声明一个数组的时候，栈空间存储数组名，但是没有内存地址。当对数组进行实例化之后，JVM会在堆空间中分配一块连续的空间来保存数组。JVM不会给数组中的每一个元素分配地址。只会给数组分配一个首地址。然后栈空间的数组名指向这个首地址。数组中每一个元素的地址实际上是相对数组首地址的偏移量。即数据元素是以偏移地址的形式访问的。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
// 从对象 tab 即我们的数组，指定 偏移地址 处获取变量的引用
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}第二个if判断本质上是把数据插入到集合中去，如果插入成功则跳出循环。失败则执行循环内后续代码。
put方法-数据插入成功
数据插入成功之后，最终会执行addCount方法。该方法的主要功能是计数，计算集合内元素个数。
addCount方法这里主要做了两件事
1.计数，通过逻辑判断采用并发场景下计数或非并发场景下计数。
总结：ConcurrentHashMap数据插入成功之后会调用addCount方法进行计数，当没有竞争的时候，通过cas操作BASECOUNT变量进行元素个数统计。当在并发场景下的时候。使用CounterCell数组来记录元素个数。
2.扩容阶段
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// 首先判断 counterCells 是否为空
// 1.如果为空，通过 cas 操作尝试修改 baseCount 变量，对该变量进行原子累加操作。
// 意义：若无竞争，采用 baseCount 来记录元素个数
// 2.如果 cas 失败，说明存在竞争，这个时候通过 CounterCell 数组 来记录
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
// 是否冲突标识，默认没有冲突
boolean uncontended = true;
// 一共有四个判断
// 1.2 如果 CounterCell 数组为空或长度，直接调用 fullAddCount
// 3. 从数组中 取出一个元素的位置数据为空， 直接调用 fullAddCount
// 4. 通过cas操作修改CounterCell随机位置的值，如果修改失败说明存在并发 调用fullAddCount
// CounterCell数组中的元素用来记录元素个数，如果cas成功，则 v+x 的值更新到数组中去，v：当前元素个数 x：新增元素个数
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();
}
......
}CounterCell数组，通过分析代码。在并发场景下，ConcurrentHashMap是通过CounterCell数组来记录元素个数的。
为什么要使用数组来记录元素个数？
原因：ConcurrentHashMap是并发集合，在并发场景下，单个变量统计元素个数势必会影响程序性能。所以，使用数组来记录元素个数。体现了“分而治之”的思想，即分片记录元素个数。
CounterCell数组中的每个元素，都存储着一个元素个数。sumCount方法通过循环累加来得到集合的大小。
private transient volatile CounterCell[] counterCells;
@sun.misc.Contended static final class CounterCell {
volatile long value;
CounterCell(long x) { value = x; }
}
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}fullAddCount方法
fullAddCount方法在addCount方法中最终会被调用。fullAddCount方法体现了“分而治之”的思想。
主要用来初始化CounterCell数组，记录元素个数，扩容等操作
提出问题：ConcurrentHashMap是如何记录元素个数的？
Answer：在单线程的情况下，ConcurrentHashMap采用CAS操作全局变量的方式统计元素个数。在并发场景下，采用数组存储元素个数的形式去记录。具体做法：每一个线程会获取一个随机数，各个线程拥有的随机数不相同。通过计算，每一个线程可以同时去操作不同的数组位置，把各自处理的元素个数存储到对应的位置。体现了“分而治之”的思想。当线程数量较多时，会对记录元素个数的数组进行扩容，数组长度默认为2，每次扩容一倍。
扩展：如何保证各个线程拥有不同的随机数？
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
// 获取当前线程的 probo 的值，即随机数 如果为0 进行初始化
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
// 重新获取随机数
h = ThreadLocalRandom.getProbe();
// 重新设置了随机数，冲突标志位设置为 true
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;;) { // 自旋
CounterCell[] as; CounterCell a; int n; long v;
// 判断 counterCells 是否已经进行初始化
if ((as = counterCells) != null && (n = as.length) > 0) {
// 当前数组长度减一 和 当前线程的随机数 进行 & 运算，
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to attach new Cell
// 构造一个 CounterCell 元素，传入元素个数
CounterCell r = new CounterCell(x); // Optimistic create
// 通过cas操作设置标识位 为 1 防止其它线程对 counterCells 做并发处理
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
// 将初始化的 CounterCell 对象 r 放到数组对应下标位置
CounterCell[] rs; int m, j;
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;
}
} finally {
cellsBusy = 0;
}
if (created)
break;
// 创建成功退出循环，cells下标位置数据不为空，进行下一次循环。
continue; // Slot is now non-empty
}
}
collide = false;
}
// 表示 在 addCount 方法中 cas 失败了，且获取的 probe 不为空
else if (!wasUncontended) // CAS already known to fail
// 重置冲突标识，进行下一次自旋
wasUncontended = true; // Continue after rehash
// 指定下标位置的 cell 不为空， 通过 cas 操作进行原子累加，如果成功，直接退出
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
// 两个判断 1.是否有其它线程建立了新的 counterCells
// 2.counterCells的大小，大于cpu的核心数（线程的并发数不会大于cpu的核心数）
else if (counterCells != as || n >= NCPU)
// 设置当前循环失败，，不进行扩容
collide = false; // At max size or stale
// 恢复状态 下一次进行扩容
else if (!collide)
collide = true;
// 进行扩容
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (counterCells == as) {// Expand table unless stale
// 扩容一倍 2->4
CounterCell[] rs = new CounterCell[n << 1];
for (int i = 0; i < n; ++i)
rs[i] = as[i];
counterCells = rs;
}
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
// 更新随机数的值
h = ThreadLocalRandom.advanceProbe(h);
}
// 初始化 CounterCell 数组
// cellsBusy ： 标识位 0 表示没有在做初始化，通过cas更新cellsBusy的值，1 标识 当前线程正在做初始化操作
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
if (counterCells == as) {
// 数组的初始化长度为2
CounterCell[] rs = new CounterCell[2];
// 把元素个数 x 放在指定的数组下标位置
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
// 恢复标识
cellsBusy = 0;
}
if (init)
break;
}
// 并发场景下，竞争激烈，直接累加元素个数到 BASECOUNT 变量中
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}ConcurrentHashMap扩容阶段
addCount方法第二阶段
首先要判断是否需要扩容，判断逻辑为当前数组大小是否大于自身容量的0.75倍。且数组容量小于最大容量。证明此时数组可以进行扩容.。
// binCount >= 0 链表长度总是大于等于0 检查是否需要扩容
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// s 表示集合大小 如果集合大小 大于等于 扩容阈值（当前容量的0.75倍） 并且table容量不为空且长度小于最大容量
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// 生成一个扩容戳
int rs = resizeStamp(n);
// sc < 0 即 sizeCtrl < 0 说明已经有别的线程正在扩容了
if (sc < 0) {
// 5个判断 true：表示当前线程不能帮助此次扩容，直接跳出循环
// 1. sc >>> RESIZE_STAMP_SHIFT!=rs 表示比较高 RESIZE_STAMP_BITS 位
// 生成戳和 rs 是否相等
// 2. sc=rs+1 表示扩容结束
// 3. sc==rs+MAX_RESIZERS 表示帮助线程线程已经达到最大值了
// 4. nt=nextTable -> 表示扩容已经结束
// 5. transferIndex<=0 表示所有的 transfer 任务都被领取完了，没有剩余的
// hash 桶来给自己自己好这个线程来做 transfer
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 当前线程尝试帮助扩容，成功则，调用 transfer 方法进行扩容
// sc+1 表示增加一个线程去帮助进行扩容操作。
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 如果当前没有在扩容，那么 rs 肯定是一个正数，通过 rs<<RESIZE_STAMP_SHIFT
// 将sc 设置为一个负数，+2 表示有一个线程在执行扩容
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
// 重新计数
s = sumCount();
}
}在while循环条件中，sizeCtl的值被赋值给变量sc 即如果满足扩容条件会首先执行如下代码。首先让一个线程去执行扩容操作。
else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);扩容戳-resizeStamp方法
Integer.numberOfLeadingZeros(n)返回了一个无符号整数n的最高非零位前面0的个数。
10的2进制数是 0000 0000 0000 0000 0000 0000 0000 1010 返回28
static final int resizeStamp(int n) {
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}假定 n = 16 resizeStamp(16) = 32795
转化为二进制是
【0000 0000 0000 0000 1000 0000 0001 1011】
当第一个线程尝试进行扩容会执行如下代码
U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2);rs左移16位变为 【1000 0000 0001 1011 0000 0000 0000 0000】
然后再＋2变为 【1000 0000 0001 1011 0000 0000 0000 0010】
结论：高16位代表扩容的标记 低16位代表并行扩容的线程数
第一次扩容为什么+2？
原因：1表示初始化，2表示一个线程正在扩容，对sizeCtrl的操作都是基于位运算的，所以不会关心具体数值是多少，只关心其在二进制上的数值。
transfer-多线程下的扩容
CAS实现无锁的并发同步策略，利用多线程来进行协同扩容
关键点1：当前数组长度右移三位除以CPU核心线程数，是否小于16.目的是平均为CPU分配任务，让每一个CPU可以处理至少16个长度的数组，以达到平均分配的效果。
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; transfer方法源码注释版
问题：ConcurrentHashMap如何实现扩容？
Answer：ConcurrentHashMap支持并发扩容，实现方式是把node数组进行拆分，让每个线程处理自己的区域。拆分数组的方式首先是通过CPU核心线程数计算出每个线程适合处理的数组长度。
假如一个容量为32的ConcurrentHashMap集合需要进行扩容，参与扩容的每一个线程适合处理的数组长度为16.
计算好每个数组处理的数组长度后，开始给每一个线程分配具体的数据迁移任务。容量为32的集合进行扩容，一个线程适合处理的数组长度是16。此时假如线程A和B2个线程并行扩容。最终会为线程A分配0-15位置的数组进行处理，线程B分配16-31位置的数组进行处理。从而实现并行扩容。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// 计算结果 小于 16 则直接赋值为 16
// 目的是为了让每一个CPU的任务尽量均匀，默认一个CPU处理 16 个 bucket
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// nextTab : 用来扩容的数组，未初始化
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
// 新建一个原始table 2倍大小的 nt 赋值给 nextTab
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
// 把新建的 table 赋值给入参 nextTab （入参为 null 的情况下）
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
// 扩容失败 sizeCtrl 使用 int 的最大值
sizeCtl = Integer.MAX_VALUE;
return;
}
// 把新建的 table 再赋值给全局变量 nextTable
nextTable = nextTab;
// 把数组长度 赋值给 transferIndex
transferIndex = n;
}
// nextn : 新的 table 长度
int nextn = nextTab.length;
// 创建一个 fwd 节点，表示一个正在被迁移的Node 并且 hash 值为 -1（MOVED） 标识正在迁移
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
// 判断是否已经完成了扩容
boolean finishing = false; // to ensure sweep before committing nextTab
// 通过for自循环处理每个槽位中的链表元素 advance 默认为 true
// 通过 CAS 设置 transferIndex 属性值，并初始化 i 和 bound 值
// i 指当前处理的槽位序号， bound 指需要处理的槽位边界，先处理槽位 15 的节点
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 循环使用 CAS 不断尝试为当前线程分配任务,直到分配成功或任务队列已经被全部分配完毕
// 如果当前线程已经被分配过 bucket 区域 那么会通过--i 指向下一个待处理 bucket 然后退出该循环
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
// transferIndex <= 0 表示没有需要处理的 bucket 了
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 假如对数组容量为 32 的目标数组进行扩容，那么此时nextIndex的值为32 stride的值为16
// 所以计算得出 nextBound的值为 16 即更新 transferIndex 的值为16
// nextBound = (nextIndex > stride ? nextIndex - stride : 0)
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
// 此时 bound = 16
bound = nextBound;
// i = 31
i = nextIndex - 1;
advance = false;
}
}
// i 表示目前处理数组下标节点 这里三个判断是用来判断是否完成了数据迁移
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
// 如果完成了扩容 删除成员变量
nextTable = null;
// 更新 table 数组
table = nextTab;
// 更新阈值 16->12 32->24
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// CAS 操作，对 sizeCtl 变量的低16位进行减一操作，表示一个线程完成了属于自己的数据迁移， 相当于对数据进行复位
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 前面有 sc+2 的操作，这里 判断如果相等了，表明已经完成了扩容操作
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 如果相等，扩容结束了，更新 finising 变量
finishing = advance = true;
// 再次循环检查一下整张表
i = n; // recheck before commit
}
}
// 如果位置 i 处是空的，没有任何节点，
// 那么放入刚刚初始化的 ForwardingNode ”空节点“
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 目标节点状态为 MOVED 表明当前节点已经被处理过了，其它线程不再进行处理
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 具体的数据迁移过程
.....
}
}
630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
