ConcurrentHashMap put源码解析 JDK8
sizeCtl需要了解的
sizeCtl的正确解释： https://blog.csdn.net/Unknownfuture/article/details/105350537
sizeCtl可以说它是ConcurrentHashMap中出镜率很高的一个属性，因为它是一个控制标识符，在不同的地方有不同用途，而且它的取值不同，也代表不同的含义。
table未初始化：
sizeCtl=0：表示没有指定初始容量；
sizeCtl>0：表示初始容量；
初始化中：
sizeCtl= -1,标记作用，告知其他线程，table正在初始化；
正常状态：
sizeCtl=0.75n ,扩容阈值；
扩容中:
sizeCtl < 0 : 表示有其他线程正在执行扩容；当在扩容的时候，可间接的理解这个变量是记录的扩容线程的个数。其实是在当第一个线程去执行扩容时，会给sizeCtl 一个值，而这个是是一个非常小的负数（例如-214545411），反正就是非常小，当增加一个线程扩容时，sizeCtl +1，当有线程扩容完成是sizeCtl -1；
需要了解的变量
/**
* 盛装Node元素的数组 它的大小是2的整数次幂
*/
transient volatile Node<K,V>[] table;
/**
hash表初始化或扩容时的一个控制位标识量。
负数代表正在进行初始化或扩容操作
-1代表正在初始化
-N 表示有N-1个线程正在进行扩容操作
正数或0代表hash表还没有被初始化，这个数值表示初始化或下一次进行扩容的大小
*/
private transient volatile int sizeCtl;
// 以下两个是用来控制扩容的时候 单线程进入的变量
private static int RESIZE_STAMP_BITS = 16;
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
static final int MOVED = -1; // hash值是-1，表示这是一个forwardNode节点
static final int TREEBIN = -2; // hash值是-2 表示这时一个TreeBin节点
Node对象
Node是最核心的内部类，它包装了key-value键值对，所有插入ConcurrentHashMap的数据都包装在这里面。它与HashMap中的定义很相似，但是有一些差别它对value和next属性设置了volatile关键字，它不允许调用setValue方法直接改变Node的value值，它增加了find方法辅助map.get()方法。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;//带有同步锁的value
volatile Node<K,V> next;//带有同步锁的next指针
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
public final String toString(){ return key + "=" + val; }
//不允许直接改变value的值
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
public final boolean equals(Object o) {
Object k, v, u; Map.Entry<?,?> e;
return ((o instanceof Map.Entry) &&
(k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
(v = e.getValue()) != null &&
(k == key || k.equals(key)) &&
(v == (u = val) || v.equals(u)));
}
/**
* Virtualized support for map.get(); overridden in subclasses.
*/
Node<K,V> find(int h, Object k) {
Node<K,V> e = this;
if (k != null) {
do {
K ek;
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
} while ((e = e.next) != null);
}
return null;
}
}
常见的CAS方法
@SuppressWarnings("unchecked")
//获得在i位置上的Node节点
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
//利用CAS算法设置i位置上的Node节点。之所以能实现并发是因为他指定了原来这个节点的值是多少
//在CAS算法中，会比较内存中的值与你指定的这个值是否相等，如果相等才接受你的修改，否则拒绝你的修改
//因此当前线程中的值并不是最新的值，这种修改可能会覆盖掉其他线程的修改结果 有点类似于SVN
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
//利用volatile方法设置节点位置的值
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
put方法
当线程put时又恰好遇到别的线程在扩容，这个时候如果操作的是同一个桶位，会造成阻塞，因为put值和扩容时都会synchronized 锁住head对象；
从put方法为入口开始讲解，过程中需要跳转看以下两个方法的源码。
initTable()初始化方法的源码；
ForwardNode类的作用；
addCount()方法的源码；
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();//这里看得出来，K、V都不能为空，和HashMap不一样
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();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//判断该位置是否被占
//casTabAt CAS放值在该位置，成功则退出循环；所以初始化节点时，时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) //hash值是-1，表示这是一个forwardNode节点，当该桶位被扩容后，该位置就会变成forwardNode节点，啥叫ForwardNode类？？？
tab = helpTransfer(tab, f);//如果该map正在扩容，则去帮助扩容，这个方法本质还是去调用了transfer方法
else {
V oldVal = null;
synchronized (f) {//到这里时，就表示该桶位的已经有节点了，这里锁住head对象
if (tabAt(tab, i) == f) {//双重校验，该桶位的head对象是否发生变化
if (fh >= 0) {//判断该节点处于什么状态，有几个状态数小于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) {
if (binCount >= TREEIFY_THRESHOLD) //判断是否需要转成红黑树
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
initTable()初始化table
初始化方法主要应用了关键属性sizeCtl，如果这个值sizeCtl<0，表示其他线程正在进行初始化，就放弃这个操作。在这也可以看出ConcurrentHashMap的初始化只能由一个线程完成。 如果获得了初始化权限，就用CAS方法将sizeCtl置为-1，防止其他线程进入。 初始化数组后，将sizeCtl的值改为0.75*n，表示扩容阈值。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield(); //进来这里，表示已有线程在初始化该map了，让出CPU时间片
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//去标记该初始化被我抢到了，标记成功则执行下面的初始化方法
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);//这个可以理解成0.75*n，记录扩容阈值
}
} finally {
sizeCtl = sc;//赋值扩容阈值
}
break;
}
}
return tab;
}
ForwardNode类
ForwardingNode是继承了Node类的
- 该类的作用是作为连接老table和新table的桥梁；
- 还有个作用：表示该桶位已经被其他线程扩容移动了；
具体作用：例如，在扩容过程中，下标15的桶数据已经被移到新table中去了，在移动完成后，老table的15位置会被置换成ForwardNode类。当有线程调用get方法查询15下标的数据时（假如这时整个Map的扩容还未完成，也就是新table还未替代老table），这时的get方法查找值就需要通过ForwardNode这个类中的find方法去新table查询。
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {//这个tab参数是再扩容时传进来的，代表新的table
super(MOVED, null, null, null);
this.nextTable = tab;
}
Node<K,V> find(int h, Object k) {
// loop to avoid arbitrarily deep recursion on forwarding nodes
outer: for (Node<K,V>[] tab = nextTable;;) {
Node<K,V> e; int n;
if (k == null || tab == null || (n = tab.length) == 0 ||
(e = tabAt(tab, (n - 1) & h)) == null)
return null;
for (;;) {
int eh; K ek;
if ((eh = e.hash) == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
if (eh < 0) {
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
continue outer;
}
else
return e.find(h, k);
}
if ((e = e.next) == null)
return null;
}
}
}
}
addCount方法（就是size+1）
读这个方法前，必须先去读下Map中的size方法，看看源码是如何返回Map大小的；
接put方法63行代码
baseCount表示的是当前记录当前map的大小，但Map并不一定是这么大，具体原因看size方法；
下面的参数值只代表从put方法过来时的意思
参数x：值为1，就是用来size+1的
参数check：记录的当前链表或者tree的大小
注意：代码的12行，这个return，当fullAddCount(x, uncontended);执行完成后，会直接return，所以ConcurrentHashMap的扩容时机不一定的，不是说达到阈值就会去扩容的。
看这个方法过程中，需要看看
fullAddCount方法
还有最重要的transfer扩容方法
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
if ((as = counterCells) != null || //重要：：如果counterCells不是空的，都不会再去CAS做baseCount加1，也就是baseCount并不再是完整的Map大小了
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {//这个CAS就是去做baseCount加1，如果不成功，则会在fullAddCount方法去加1
CounterCell a; long v; int m;
boolean uncontended = true;
if (as == null || (m = as.length - 1) < 0 || //这俩判断CounterCell[]有没有被初始化
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||//表示在CounterCell[]不为空的前提下，判断当前线程该去哪个下标下做value加1;
!(uncontended = //ThreadLocalRandom.getProbe这个是给线程生成一个随机值，同一个线程多次调用也不会改变
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {//如果在CounterCell中value加1成功，则表示计数size+1成功，退出if
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();//这个是去计算了当前map的大小
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
//当达到扩容阈值，且Map不为空，且没达到阈值最大值；为什么是while，可能存在第一次扩容完成后，map的大小又被其他线程put到阈值了，还需要一次扩容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {//当第一个线程进来时，sc < 0是不成立的，必须先执行34行代码
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0) //这个分支进来后，该线程都不会去帮助扩容了，break了
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))//能执行到这里，SIZECTL这个变量必定在33行代码赋值过一次了，sc + 1可以理解为来一个帮助线程就+1，
//在transfer方法的59行，有sc-1，就是表示该线程已完成扩容任务，退出扩容了
transfer(tab, nt);
}
//多个线程进来这个while循环时，只有当某个线程成功的CAS后，别的线程都只能走上面的那个分支了，(rs << RESIZE_STAMP_SHIFT) + 2)的结果为-214112511，反正就是很小的负数
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2)) //（SIZECTL这个变量现在可以近似理解为有多少线程去扩容）这个CAS操作做其实是给SIZECTL做了一个初始值，有且仅有一个线程能做这个初始值
transfer(tab, null);
s = sumCount();
}
}
}
size方法源码
在ConcurrentHashMap中不像HashMap中有个变量专门拿去计数，ConcurrentHashMap中并发时，计数是通过baseCount这个成员变量和CounterCell[]数组对象中的value共同完成的。
下面就是size方法调用的真实方法，该方法其实是去统计的counterCells数组的value值，这个counterCells在上面addCount方法中做的具体赋值
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;//累加value值
}
}
return sum;
}
fullAddCount方法源码
这个方法是做CounterCell[]数组的初始化，或者对CounterCell[]数组的某一个下标做初始化，或者就是对某个下标的CounterCell的value做加1；
参数x: 必定为1
参数wasUncontended：在CounterCell[]数组未初始化和某个下标未初始化的情况下为true，在CAS操作失败的情况下，这个参数为false；
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
//这个if判断则表示该线程的随机数是否生成，ThreadLocalRandom.getProbe()是获取当前线程的随机数
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false;//这个参数的作用，我理解的是，尽量去减少CounterCell数组的扩容几率（也可以说是减少线程之前的冲突），当collide为true时，可能会发生数组扩容，第47行的分支代码，其实可以看出，这个扩容分支都是最后才去执行
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
//这个分支表示该数组已经被初始化了
if ((as = counterCells) != null && (n = as.length) > 0) {
//这个分支是表示该下标的counterCell对象还未创建，在这个分支进行初始化
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // 判断cellsBusy==0表示还没有线程用counterCells这个数组对象
CounterCell r = new CounterCell(x); // 初始化该下标的counterCell对象
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {//CAS修改cellsBusy=1，表示counterCells已经有线程再用了
boolean created = false;//这个参数是用来表示下面try中的代码是否执行完成
try {
CounterCell[] rs; int m, j;
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) { //再次重复校验当前下标位置的counterCell对象是否初始化
rs[j] = r;
created = true;
}
} finally {
cellsBusy = 0;
}
if (created)
break; //上面那个try中代码执行成功，则表示size+1成功
continue;
}
}
collide = false;
}
else if (!wasUncontended) //为什么会有这段代码？能进到这里，表示当前线程计算的下标位置在counterCells数组中是已经初始化了的，但是当前线程在addCount方法第10行没有CAS成功，
wasUncontended = true; //当这个分支走完后，就会直接执行62行代码，这个代码会重新计算一个下标给这个线程，避开其他线程
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)) //(能走到这里，如果wasUncontended之前是初始化值是fasle，表示当前线程可能是换了一个随机值去计算下标了)；表示当前下标位置的对象不为空，去做一次CAS value+1
break;
else if (counterCells != as || n >= NCPU)
collide = false; //43行和45行分支，我理解的作用是，尽量不要去出发最后那个分支的扩容，尽量在上面分支完成value+1的操作
else if (!collide)
collide = true;
else if (cellsBusy == 0 && //cellsBusy这个参数表示有没有其他线程去操作CounterCell数组
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) { //能进这个扩容分支，collide的值必定为true了，但是为什么不直接把collide这个值省略呢，感觉就是为了减少扩容概率
try {
if (counterCells == as) {// Expand table unless stale
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);//这个步骤的作用：表示前面都没完成size+1，这里就重新生成一个线程的随机码，避开其他线程的竞争
}
//如果进这个分支，则表示counterCells数组都还未出初始化；cellsBusy==0表示还没有其他线程进去初始化，
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {//CAS设置cellsBusy为1
boolean init = false;
try { // Initialize table
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2];//初始化CounterCell长度为0
rs[h & 1] = new CounterCell(x);//为这次put记录加1，这里其实做加操作就完成了
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;//将该值改回0
}
if (init)
break;//本次初始化CounterCell数组和记录Map大小已完成
}
//下面这个分支的情况是：假如有2个线程同时去做CounterCell数组的初始化（就是抢上个分支的CAS操作），其中一个线程必定失败，
//那么失败的那个线程就会直接再去操作BASECOUNT这个变量做size+1
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
扩容方法 transfer
扩容迁移是从右往左的，也就是先迁移最大的下标位置数据=
当ConcurrentHashMap容量不足的时候，需要对table进行扩容。这个方法的基本思想跟HashMap是很像的，但是由于它是支持并发扩容的，所以要复杂的多。原因是它支持多线程进行扩容操作，而并没有加锁。我想这样做的目的不仅仅是为了满足concurrent的要求，而是希望利用并发处理去减少扩容带来的时间影响。因为在扩容的时候，总是会涉及到从一个“数组”到另一个“数组”拷贝的操作，如果这个操作能够并发进行，那真真是极好的了。
整个扩容操作分为两个部分
-
第一部分是构建一个nextTable,它的容量是原来的两倍，这个操作是单线程完成的。这个单线程的保证是通过RESIZE_STAMP_SHIFT这个常量经过一次运算来保证的，这个地方在后面会有提到；
-
第二个部分就是将原来table中的元素复制到nextTable中，这里允许多线程进行操作。
先来看一下单线程是如何完成的：
它的大体思想就是遍历、复制的过程。首先根据运算得到需要遍历的次数i，然后利用tabAt方法获得i位置的元素：
如果这个位置为空，就在原table中的i位置放入forwardNode节点，这个也是触发并发扩容的关键点；
如果这个位置是Node节点（fh>=0），如果它是一个链表的头节点，就构造一个反序链表，把他们分别放在nextTable的i和i+n的位置上
如果这个位置是TreeBin节点（fh<0），也做一个反序处理，并且判断是否需要untreefi，把处理的结果分别放在nextTable的i和i+n的位置上
遍历过所有的节点以后就完成了复制工作，这时让nextTable作为新的table，并且更新sizeCtl为新容量的0.75倍 ，完成扩容。
再看一下多线程是如何完成的：
在代码的69行有一个判断，如果遍历到的节点是forward节点，就向后继续遍历，再加上给节点上锁的机制，就完成了多线程的控制。多线程遍历节点，处理了一个节点，就把对应点的值set为forward，另一个线程看到forward，就向后遍历。这样交叉就完成了复制工作。而且还很好的解决了线程安全的问题。 这个方法的设计实在是让我膜拜。
transferIndex变量含义和步长
transferIndex扩容索引，例如Map大小为16，下标为0到15，当地一个线程1去获取扩容区间时，transferIndex的值15，如果扩容步长大小为4，那么当线程1获取扩容区间后，transferIndex的值就会变为11。当transferIndex==0时，表示扩容工作被分配完成了。
扩容线程，在迁移数据之前，首先要将transferIndex右移（以cas的方式修改 transferIndex=transferIndex-stride(要迁移hash桶的个数)），获取迁移任务。每个扩容线程都会通过for循环+CAS的方式设置transferIndex，因此可以确保多线程扩容的并发安全。
换个角度，我们可以将待迁移的table数组，看成一个任务队列，transferIndex看成任务队列的头指针。而扩容线程，就是这个队列的消费者。扩容线程通过CAS设置transferIndex索引的过程，就是消费者从任务队列中获取任务的过程。为了性能考虑，我们当然不会每次只获取一个任务（hash桶），因此ConcurrentHashMap规定，每次至少要获取16个迁移任务（迁移16个hash桶，MIN_TRANSFER_STRIDE = 16）
rivate transient volatile int transferIndex;
/**
扩容线程每次最少要迁移16个hash桶，也叫最小步长
*/
private static final int MIN_TRANSFER_STRIDE = 16;
transfer源码
/**
* 一个过渡的table表 只有在扩容的时候才会使用
*/
private transient volatile Node<K,V>[] nextTable;
/**
* 扩容迁移是从右往左的，也就是先迁移最大的下标位置数据
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;//stride 这个是指每个线程负责迁移桶的个数
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)// MIN_TRANSFER_STRIDE这个是每个线程负责迁移桶数的最小个数
stride = MIN_TRANSFER_STRIDE; // 最小个数为MIN_TRANSFER_STRIDE = 16
if (nextTab == null) { // 初始化新table
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];//构造一个nextTable对象 它的容量是原来的两倍
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;//transferIndex详细请看transferIndex属性介绍
}
int nextn = nextTab.length;
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);//理解为桥梁，当老Map的一个Node节点被转移后，这里就放ForwardingNode类节点，表示已扩容完成，也可以用于get请求时的桥梁，读取转移后的数据
boolean advance = true;//如果为true，就是要去获取扩容区间，如果为fasle，表示:情况1=》之前获取的扩容区间还未转移完成；情况2=》表示已经不需要该线程再去获取扩容空间了（其他线程已经帮忙扩容了）
boolean finishing = false; //表示整个map的所有下标都有线程去帮忙扩容了，不需要你再去帮忙了
for (int i = 0, bound = 0;;) {//i表示扩容的桶位，bound表示该线程负责扩容的界限值。例如map长16，每个线程负责扩容步长为4，如果该线程是第一个参与扩容的线程，那么当前i和bound的值为15和12
Node<K,V> f; int fh;
//这个while循环体的作用就是：获取当前线程负责扩容的区间，如果获取成功，就会给i和bound赋值
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)//--i >= bound 这个如果成立，则说明该线程负责的区间还未扩容完成；
advance = false;
else if ((nextIndex = transferIndex) <= 0) {//表示所有桶位都有线程负责扩容了。请看transferIndex的意义
i = -1;
advance = false;
}
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) { //这里就是去修改transferIndex这个变量，成功了则表示该线程拿到了扩容的区间范围
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {//获取到扩容区间后，第一次走走这里是不会进去的
int sc;
if (finishing) {
//如果所有的节点都已经完成复制工作 就把nextTable赋值给table 清空临时对象nextTable
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);//扩容阈值设置为原来容量的1.5倍 依然相当于现在容量的0.75倍
return;
}
//sc - 1表示当前线程即将退出扩容，将自己减出去，在addCount方法的29行代码将该线程+1的；
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)//这个分支的意思就是，看sc有没有回到初始值，如果回到了初始值，就表示所有线程都已扩容完成；如果没有，则return，我的活干完了
return; //sc或SIZECTL这个值可以理解成记录有多少个线程来一起扩容的
finishing = advance = true;//如果上面return没执行，则表示所有扩容的线程都完成了，再次29行for循环时，就会去执行51行的那个分支，结束整个扩容
i = n; // 执行这句后，49行的i >= n 条件就会成立
}
}
//如果遍历到的节点为空 则放入ForwardingNode指针
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
advance = true; // 这个是为了保险，判断当前桶位是否为ForwardingNode节点
else {
//节点上锁
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
//如果fh>=0 证明这是一个Node节点
if (fh >= 0) {
int runBit = fh & n;//计算当head节点旧map中的运算结果，这个是一个比较依据，这个runBit也会改变的，90行
/**以下的部分在完成的工作是构造两个链表，这里转移和Hashmap是不同的，
*这里有部分node节点是需要重新new出来再赋值放在新数组里面，这里为了减少垃圾的产生，提升效率，有部分node节点是不会重新新对象的；
*那么哪部分node是不需要重新new的呢？这部分必定是再尾部，举例说明；
*例如当前桶位有4个node对象的链表，如果第3个node对象在新map中计算的下标和旧map的下标不一样，并且第4个node对象在新map中计算的下标和第3个node对象的下标一样，
*这样的话，从第3个下标的node对象开始到结尾，这段链表就不需要再new新的node对象了，具体的代码看86行和102行，这里的lastRun就是表示的是举例中的第3个node对象
*/
Node<K,V> lastRun = f;//最终表示从哪个node对象开始不用重新new对象
for (Node<K,V> p = f.next; p != null; p = p.next) {//这个循环就是为了找出lastRun
int b = p.hash & n;//计算当node节点旧map中的运算结果
if (b != runBit) {//比较他俩是不是一样的，如果不一样，就换值，当最后一次进来后，
runBit = b; //（接上行注释）则表示lastRun之后的节点和lastRun这个节点必定是再新Map的同一个下标中，这段链表的node就不会再new了
lastRun = p;
}
}
if (runBit == 0) {//这里是判断上面循环完成后，runBit的值，如果等于0，则表示lastRun之后的所有node节点在新Map的下标位置不变
ln = lastRun;
hn = null;
}
else {
hn = lastRun;//这里则表示lastRun之后的所有node节点的下标在新MMap中是i+n这个下标，意思就是发生了位移
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {//p != lastRun这个条件就可以看出我上面说的，lastRun之后的Node是不需要再new的了
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);//这里都是头插法
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
//在nextTable的i位置上插入一个链表
setTabAt(nextTab, i, ln);
//在nextTable的i+n的位置上插入另一个链表
setTabAt(nextTab, i + n, hn);
//在table的i位置上插入forwardNode节点 表示已经处理过该节点
setTabAt(tab, i, fwd);
//设置advance为true 返回到上面的while循环中 就可以执行i--操作
advance = true;
}
//对TreeBin对象进行处理 与上面的过程类似
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;
//构造正序和反序两个链表
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;
}
}
//如果扩容后已经不再需要tree的结构 反向转换为链表结构
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;
//在nextTable的i位置上插入一个链表
setTabAt(nextTab, i, ln);
//在nextTable的i+n的位置上插入另一个链表
setTabAt(nextTab, i + n, hn);
//在table的i位置上插入forwardNode节点 表示已经处理过该节点
setTabAt(tab, i, fwd);
//设置advance为true 返回到上面的while循环中 就可以执行i--操作
advance = true;
}
}
}
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
