ConcurrentHashMap1.8 源码分析

一、容器初始化

在jdk8的ConcurrentHashMap中一共有5个构造方法，这四个构造方法中都没有对内部的数组做初始化，只是对一些变量的初始值做了处理

jdk8的ConcurrentHashMap的数组初始化是在第一次添加元素时完成

//没有维护任何变量的操作，如果调用该方法，数组长度默认是16
public ConcurrentHashMap() {}

//传递进来一个初始容量，ConcurrentHashMap会基于这个值计算一个比这个值大的2的幂次方数作为初始容量
public ConcurrentHashMap(int initialCapacity) {if (initialCapacity < 0)throw new IllegalArgumentException();int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?MAXIMUM_CAPACITY :tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));this.sizeCtl = cap;
}

注意，调用这个方法，得到的初始容量和我们之前讲的HashMap以及jdk7的ConcurrentHashMap不同，即使你传递的是一个2的幂次方数，该方法计算出来的初始容量依然是比这个值大的2的幂次方数

//调用四个参数的构造
public ConcurrentHashMap(int initialCapacity, float loadFactor) {this(initialCapacity, loadFactor, 1);
}

//计算一个大于或者等于给定的容量值，该值是2的幂次方数作为初始容量
public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)throw new IllegalArgumentException();if (initialCapacity < concurrencyLevel)   // Use at least as many binsinitialCapacity = concurrencyLevel;   // as estimated threadslong size = (long)(1.0 + (long)initialCapacity / loadFactor);int cap = (size >= (long)MAXIMUM_CAPACITY) ?MAXIMUM_CAPACITY : tableSizeFor((int)size);this.sizeCtl = cap;
}

//基于一个Map集合，构建一个ConcurrentHashMap
//初始容量为16
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {this.sizeCtl = DEFAULT_CAPACITY;putAll(m);
}

`sizeCtl`含义解释

注意：以上这些构造方法中，都涉及到一个变量sizeCtl，这个变量是一个非常重要的变量，而且具有非常丰富的含义，它的值不同，对应的含义也不一样，这里我们先对这个变量不同的值的含义做一下说明，后续源码分析过程中，进一步解释

sizeCtl为0，代表数组未初始化，且数组的初始容量为16

sizeCtl为正数，如果数组未初始化，那么其记录的是数组的初始容量，如果数组已经初始化，那么其记录的是数组的扩容阈值

sizeCtl为-1，表示数组正在进行初始化

sizeCtl小于0，并且不是-1，表示数组正在扩容， -(1+n)，表示此时有n个线程正在共同完成数组的扩容操作

二、添加元素

1、添加元素put/putVal方法

public V put(K key, V value) {return putVal(key, value, false);
}

final V putVal(K key, V value, boolean onlyIfAbsent) {//如果有空值或者空键，直接抛异常if (key == null || value == null) throw new NullPointerException();//基于key计算hash值，并进行一定的扰动int hash = spread(key.hashCode());//记录某个桶上元素的个数，如果超过8个，会转成红黑树int binCount = 0;for (Node<K,V>[] tab = table;;) {Node<K,V> f; int n, i, fh;//1、如果数组还未初始化，先对数组进行初始化if (tab == null || (n = tab.length) == 0)tab = initTable();   //初始化操作！//2、如果hash计算得到的桶位置没有元素，利用cas将元素添加else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//cas+自旋（和外侧的for构成自旋循环），保证元素添加安全if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))break;                   // no lock when adding to empty bin}//3、如果hash计算得到的桶位置元素的hash值为MOVED，证明正在扩容，那么协助扩容else if ((fh = f.hash) == MOVED)tab = helpTransfer(tab, f);//4 、 //hash计算的桶位置元素不为空，且当前没有处于扩容操作，进行元素添加else {V oldVal = null;//对当前桶进行加锁，保证线程安全，执行元素添加操作//普通链表 ： 尾插法//树化后 ： 插入树节点synchronized (f) {              //加锁 为节点头元素添加重量级锁，如果触发hash冲突，引发线程同步机制）！if (tabAt(tab, i) == f) {//普通链表节点if (fh >= 0) {binCount = 1;for (Node<K,V> e = f;; ++binCount) { //拿到锁后对每个节点equalsK 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，将链表转成红黑树（这个8设计到泊松分布）if (binCount >= TREEIFY_THRESHOLD)treeifyBin(tab, i);   //尝试树化，因为树化还有满足数组长度 >  64 ！//如果是重复键，直接将旧值返回if (oldVal != null)return oldVal;break;}}}//添加的是新元素，维护集合长度，并判断是否要进行扩容操作addCount(1L, binCount);    //链表长度加1return null;
}

通过以上源码，我们可以看到，当需要添加元素时，会针对当前元素所对应的桶位进行加锁操作，这样一方面保证元素添加时，多线程的安全，同时对某个桶位加锁不会影响其他桶位的操作，进一步提升多线程的并发效率

2、数组初始化，initTable方法

private final Node<K,V>[] initTable() {Node<K,V>[] tab; int sc;//cas+自旋，保证线程安全，对数组进行初始化操作while ((tab = table) == null || tab.length == 0) {//如果sizeCtl的值（-1）小于0，说明此时正在初始化， 让出cpuif ((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) {//sizeCtl为0，取默认长度16，否则去sizeCtl的值int n = (sc > 0) ? sc : DEFAULT_CAPACITY;@SuppressWarnings("unchecked")//基于初始长度，构建数组对象Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];table = tab = nt;//计算扩容阈值，并赋值给scsc = n - (n >>> 2);    // sc = n - n/4 = 0.75n ;}} finally {//将扩容阈值，赋值给sizeCtlsizeCtl = sc;}break;}}return tab;
}

3、Put加锁图解

、

梳理一下上述流程：

初始化：执行构造的时候是否传入参数，

没有传参数：初始化容量为16，sizeCtl = 0 ；
如果传入capacity ：数组table的则初始化容量为tableSize（capacity + capacity >>> 1 + 1）的结果，然后会将结果赋值给sizeCtl

接下来容器创造好后，当我们想容器添加<k,v>的时候

如果此时数组为空且长度为0，调用initTable方法，为数组初始化 (第一次都是为空，因为是懒汉模式)！
如果数组不为空，通过扰动函数确定桶位，判断桶位是否位空
- 如果位空直接cas + 自旋添加
- 如果不为空，判断当前是链表还是红黑树（注意：此处是通过synchronized为每个桶的第一个元素加锁，实现安全 + 并发）！
  - 如果是链表就逐个个euqals比较，如果存在相等就覆盖，不等就尾插法插入链表末尾！
  - 如果是红黑树就按树的插入方式

初始化并且插入的流程完成

三、计数操作

做一些赘述，方便理解

参考：https://blog.csdn.net/u011392897/article/details/60479937

1.7及以前的ConcurrentHashMap中使用了Segment，Segment能够分担所有的针对单个K-V的写操作，包括put/replace。并且Segment自带一些数据，比如Segment.count，用于处理Map的计数要求，这样就可以像put/repalce一样，分担整个Map的并发计数压力。但是1.8中没有再使用Segment来完成put/replace，虽然还是利用了锁分段的思想，但是使用的是自带的synchronized锁住hash桶中的第一个节点，没有新增别的数据。因此计数操作，被落下来了，它无法享受synchronized实现的变种分段锁带来的高效率，单独使用一个Map.size来计数，线程竞争可能会很大，比使用Segment是效率低很多。

为了处理这个问题，jdk1.8中使用了一个仿造LongAdder实现的计数器，让计数操作额外使用别的基于分段并发思想的实现的类。。ConcurrentHashMap中不直接使用LongAdder，而是自己拷贝代码实现一个内部的，主要为了方便。LongAdder的实现本身代码不是特别多，ConcurrentHashMap中的实现，基本和LongAdder一样，可以直接看做是LongAdder。

参考：https://sylvanassun.github.io/2018/03/16/2018-03-16-map_family/

在Java 7中ConcurrentHashMap对每个Segment单独计数，想要得到总数就需要获得所有Segment的锁，然后进行统计。由于Java 8抛弃了Segment，显然是不能再这样做了，而且这种方法虽然简单准确但也舍弃了性能
Java 8声明了一个volatile变量baseCount（可以看作LongAdder计数器）用于记录元素的个数，对这个变量的修改操作是基于CAS的，每当插入元素或删除元素时都会调用addCount()函数进行计数。加不进去就加数组上，保证每个线程添加元素都能统计上，最后把加上的和没加上的汇总

1、addCount方法

记录ConcurrentHashMap元素数量，会调用fullAddCount具体执行

扩容ConcurrentHashMap ，会调用transer方法具体执行扩容

private final void addCount(long x, int check) {CounterCell[] as; long b, s;//当CounterCell数组不为空，则优先利用数组中的CounterCell记录数量//或者当baseCount的累加操作失败，会利用数组中的CounterCell记录数量if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {CounterCell a; long v; int m;//标识是否有多线程竞争boolean uncontended = true;//当as数组为空//或者当as长度为0//或者当前线程对应的as数组桶位的元素为空//或者当前线程对应的as数组桶位不为空，但是累加失败if (as == null || (m = as.length - 1) < 0 ||(a = as[ThreadLocalRandom.getProbe() & m]) == null ||!(uncontended =U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {//以上任何一种情况成立，都会进入该方法，传入的uncontended是falsefullAddCount(x, uncontended);return;}if (check <= 1)return;//计算元素个数s = sumCount();  //我们在这里得到元素的个数}//接着判断是否需要扩容if (check >= 0) {Node<K,V>[] tab, nt; int n, sc;//当元素个数达到扩容阈值//并且数组不为空//并且数组长度小于限定的最大值//满足以上所有条件，执行扩容while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&(n = tab.length) < MAXIMUM_CAPACITY) {//这个是一个很大的正数int rs = resizeStamp(n);//sc小于0，说明有线程正在扩容，那么会协助扩容if (sc < 0) {//扩容结束或者扩容线程数达到最大值或者扩容后的数组为null或者没有更多的桶位需要转移，结束操作if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||transferIndex <= 0)break;//扩容线程加1，成功后，进行协助扩容操作if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))//协助扩容，newTable不为nulltransfer(tab, nt);}//没有其他线程在进行扩容，达到扩容阈值后，给sizeCtl赋了一个很大的负数//1+1=2 --》 代表此时有一个线程在扩容//rs << RESIZE_STAMP_SHIFT)是一个很大的负数else if (U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2))//扩容，newTable为nulltransfer(tab, null);s = sumCount();}}
}

2、fullAddCount方法

需要添加的个数分别累加到baseCount 上、或者累加到其他CountCell数组中的每个对象中的value属性上

private final void fullAddCount(long x, boolean wasUncontended) {int h;if ((h = ThreadLocalRandom.getProbe()) == 0) {  //获取当前线程的hash值(就是确定加到具体哪一个累加单元！)ThreadLocalRandom.localInit();     h = ThreadLocalRandom.getProbe();wasUncontended = true;}//注意：我们的辅助数组CountCell中保存的是CountCell对象，而我们value是这个对象的有一个属性，所以找到位置，还需要判断是否需要创建对象，如果需要就创建，如果不需要就直接在其value属性的基础上进行添加！//标识是否有冲突，如果最后一个桶不是null，那么为trueboolean collide = false;                // True if last slot nonemptyfor (;;) {CounterCell[] as; CounterCell a; int n; long v;//数组不为空，优先对数组中CouterCell的value累加if ((as = counterCells) != null && (n = as.length) > 0) {//线程对应的桶位为nullif ((a = as[(n - 1) & h]) == null) {if (cellsBusy == 0) {            // Try to attach new Cell//创建CounterCell对象CounterCell r = new CounterCell(x); // Optimistic create//利用CAS修改cellBusy状态为1，成功则将刚才创建的CounterCell对象放入数组中if (cellsBusy == 0 &&U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {boolean created = false;try {               // Recheck under lockCounterCell[] rs; int m, j;//桶位为空， 将CounterCell对象放入数组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;//桶位已经被别的线程放置了已给CounterCell对象，继续循环continue;           // Slot is now non-empty}}collide = false;}//桶位不为空，重新计算线程hash值，然后继续循环else if (!wasUncontended)       // CAS already known to failwasUncontended = true;      // Continue after rehash//重新计算了hash值后，对应的桶位依然不为空，对value累加//成功则结束循环//失败则继续下面判断else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))break;//数组被别的线程改变了，或者数组长度超过了可用cpu大小，重新计算线程hash值，否则继续下一个判断else if (counterCells != as || n >= NCPU)collide = false;            // At max size or stale//当没有冲突，修改为有冲突，并重新计算线程hash，继续循环else if (!collide)collide = true;//如果CounterCell的数组长度没有超过cpu核数，对数组进行两倍扩容//并继续循环else if (cellsBusy == 0 &&U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {try {if (counterCells == as) {// Expand table unless staleCounterCell[] 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数组为空，并且没有线程在创建数组，修改标记，并创建数组else if (cellsBusy == 0 && counterCells == as &&U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {boolean init = false;try {                           // Initialize tableif (counterCells == as) {CounterCell[] rs = new CounterCell[2];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}
}

3、sumCount方法

最后会调用这个方法会中所有累加单元和baseCount的值！

final long sumCount() {CounterCell[] as = counterCells; CounterCell a;//获取baseCount的值long sum = baseCount;if (as != null) {//遍历CounterCell数组，累加每一个CounterCell的value值for (int i = 0; i < as.length; ++i) {if ((a = as[i]) != null)sum += a.value;}}return sum;
}

4、size方法

返回的是我们统计好的sum值

public int size() {long n = sumCount();return ((n < 0L) ? 0 :(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :(int)n);
}

其实size()函数返回的总数可能并不是百分百精确的，试想如果前一个遍历过的CounterCell又进行了更新会怎么样？尽管只是一个估算值，但在大多数场景下都还能接受，而且性能上是要比Java 7好上太多了。

四、扩容

ConcurrentHashMap触发扩容的时机与HashMap类似，要么是在将链表转换成红黑树时判断table数组的长度是否小于阈值（64），如果小于就进行扩容而不是树化，要么就是在添加元素的时候，判断当前Entry数量是否超过阈值，如果超过就进行扩容。

1、普通扩容机制

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {int n = tab.length, stride;//如果是多cpu，那么每个线程划分任务，最小任务量是16个桶位的迁移if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)stride = MIN_TRANSFER_STRIDE; // subdivide range//如果是扩容线程，此时新数组为nullif (nextTab == null) {            // initiatingtry {@SuppressWarnings("unchecked")//两倍扩容创建新数组Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];nextTab = nt;} catch (Throwable ex) {      // try to cope with OOMEsizeCtl = Integer.MAX_VALUE;return;}nextTable = nextTab;//记录线程开始迁移的桶位，从后往前迁移transferIndex = n;}//记录新数组的末尾int nextn = nextTab.length;//已经迁移的桶位，会用这个节点占位（这个节点的hash值为-1--MOVED）ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);boolean advance = true;boolean finishing = false; // to ensure sweep before committing nextTabfor (int i = 0, bound = 0;;) {Node<K,V> f; int fh;while (advance) {int nextIndex, nextBound;//i记录当前正在迁移桶位的索引值//bound记录下一次任务迁移的开始桶位//--i >= bound 成立表示当前线程分配的迁移任务还没有完成if (--i >= bound || finishing)advance = false;//没有元素需要迁移 -- 后续会去将扩容线程数减1，并判断扩容是否完成else if ((nextIndex = transferIndex) <= 0) {i = -1;advance = false;}//计算下一次任务迁移的开始桶位，并将这个值赋值给transferIndexelse if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex,nextBound = (nextIndex > stride ?nextIndex - stride : 0))) {bound = nextBound;i = nextIndex - 1;advance = false;}}//如果没有更多的需要迁移的桶位，就进入该ifif (i < 0 || i >= n || i + n >= nextn) {int sc;//扩容结束后，保存新数组，并重新计算扩容阈值，赋值给sizeCtlif (finishing) {nextTable = null;table = nextTab;sizeCtl = (n << 1) - (n >>> 1);return;}//扩容任务线程数减1if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {//判断当前所有扩容任务线程是否都执行完成if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)return;//所有扩容线程都执行完，标识结束finishing = advance = true;i = n; // recheck before commit}}//当前迁移的桶位没有元素，直接在该位置添加一个fwd节点else if ((f = tabAt(tab, i)) == null)advance = casTabAt(tab, i, null, fwd);//当前节点已经被迁移else if ((fh = f.hash) == MOVED)advance = true; // already processedelse {//当前节点需要迁移，加锁迁移，保证多线程安全//此处迁移逻辑和jdk7的ConcurrentHashMap相同，不再赘述synchronized (f) {if (tabAt(tab, i) == f) {Node<K,V> ln, hn;if (fh >= 0) {int runBit = fh & n;Node<K,V> lastRun = f;for (Node<K,V> p = f.next; p != null; p = p.next) {int b = p.hash & n;if (b != runBit) {runBit = b;lastRun = p;}}if (runBit == 0) {ln = lastRun;hn = null;}else {hn = lastRun;ln = null;}for (Node<K,V> p = f; p != lastRun; p = p.next) {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);elsehn = new Node<K,V>(ph, pk, pv, hn);}setTabAt(nextTab, i, ln);setTabAt(nextTab, i + n, hn);setTabAt(tab, i, fwd);advance = true;}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;elseloTail.next = p;loTail = p;++lc;}else {if ((p.prev = hiTail) == null)hi = p;elsehiTail.next = p;hiTail = p;++hc;}}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;setTabAt(nextTab, i, ln);setTabAt(nextTab, i + n, hn);setTabAt(tab, i, fwd);advance = true;}}}}}
}

图解

2、多线程协助扩容

多线程协助扩容的操作会在两个地方被触发：

① 当添加元素时，发现添加的元素对用的桶位为fwd节点，就会先去协助扩容，然后再添加元素

② 当添加完元素后，判断当前元素个数达到了扩容阈值，此时发现sizeCtl的值小于0，并且新数组不为空，这个时候，会去协助扩容

1.1、元素未添加，先协助扩容，扩容完后再添加元素

final V putVal(K key, V value, boolean onlyIfAbsent) {if (key == null || value == null) throw new NullPointerException();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) {if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))break;                   // no lock when adding to empty bin}//发现此处为fwd节点，协助扩容，扩容结束后，再循环回来添加元素else if ((fh = f.hash) == MOVED)tab = helpTransfer(tab, f);//省略代码

final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {Node<K,V>[] nextTab; int sc;if (tab != null && (f instanceof ForwardingNode) &&(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {int rs = resizeStamp(tab.length);while (nextTab == nextTable && table == tab &&(sc = sizeCtl) < 0) {if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||sc == rs + MAX_RESIZERS || transferIndex <= 0)break;if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {//扩容，传递一个不是null的nextTabtransfer(tab, nextTab);break;}}return nextTab;}return table;
}

1.2、先添加元素，再协助扩容

private final void addCount(long x, int check) {//省略代码if (check >= 0) {Node<K,V>[] tab, nt; int n, sc;//元素个数达到扩容阈值while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&(n = tab.length) < MAXIMUM_CAPACITY) {int rs = resizeStamp(n);//sizeCtl小于0，说明正在执行扩容，那么协助扩容if (sc < 0) {if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||transferIndex <= 0)break;if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))transfer(tab, nt);}else if (U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2))transfer(tab, null);s = sumCount();}}
}

注意：扩容的代码都在transfer方法中，这里不再赘述

图解多线程扩容机制

               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;elseloTail.next = p;loTail = p;++lc;}else {if ((p.prev = hiTail) == null)hi = p;elsehiTail.next = p;hiTail = p;++hc;}}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;setTabAt(nextTab, i, ln);setTabAt(nextTab, i + n, hn);setTabAt(tab, i, fwd);advance = true;}}}}
}

}


**图解**<img src="JUC并发编程.assets/image-20211024150440847.png" alt="image-20211024150440847" style="zoom:80%;" />##### 2、多线程协助扩容多线程协助扩容的操作会在两个地方被触发：① 当添加元素时，发现添加的元素对用的桶位为fwd节点，就会先去协助扩容，然后再添加元素② 当添加完元素后，判断当前元素个数达到了扩容阈值，此时发现sizeCtl的值小于0，并且新数组不为空，这个时候，会去协助扩容**1.1、元素未添加，先协助扩容，扩容完后再添加元素**```java
final V putVal(K key, V value, boolean onlyIfAbsent) {if (key == null || value == null) throw new NullPointerException();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) {if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))break;                   // no lock when adding to empty bin}//发现此处为fwd节点，协助扩容，扩容结束后，再循环回来添加元素else if ((fh = f.hash) == MOVED)tab = helpTransfer(tab, f);//省略代码

final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {Node<K,V>[] nextTab; int sc;if (tab != null && (f instanceof ForwardingNode) &&(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {int rs = resizeStamp(tab.length);while (nextTab == nextTable && table == tab &&(sc = sizeCtl) < 0) {if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||sc == rs + MAX_RESIZERS || transferIndex <= 0)break;if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {//扩容，传递一个不是null的nextTabtransfer(tab, nextTab);break;}}return nextTab;}return table;
}

1.2、先添加元素，再协助扩容

private final void addCount(long x, int check) {//省略代码if (check >= 0) {Node<K,V>[] tab, nt; int n, sc;//元素个数达到扩容阈值while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&(n = tab.length) < MAXIMUM_CAPACITY) {int rs = resizeStamp(n);//sizeCtl小于0，说明正在执行扩容，那么协助扩容if (sc < 0) {if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||transferIndex <= 0)break;if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))transfer(tab, nt);}else if (U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2))transfer(tab, null);s = sumCount();}}
}

注意：扩容的代码都在transfer方法中，这里不再赘述

图解多线程扩容机制

好文推荐： https://sylvanassun.github.io/2018/03/16/2018-03-16-map_family/