JDK1.8 论ConcurrentHashMap是如何扩容的
导致扩容的情况
在了解JDK1.8的ConcurrentHashMap扩容机制之前,要先知道ConcurrentHashMap什么情况会导致扩容。
1.put操作(插入键值对)
put函数的操作要通过putVal操作,如果有特殊情况要扩容。
put操作代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 public V put(K key, V value) { 2 return putVal(key, value, false); 3 }
putVal代码(注释感谢简书作者代码potty):
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 //onlyIfAbsent跟HashMap一样,就是判断是否要覆盖,默认为false,覆盖 2 final V putVal(K key, V value, boolean onlyIfAbsent) { 3 if (key == null || value == null) throw new NullPointerException(); 4 int hash = spread(key.hashCode()); 5 //binCount=0说明首节点插入,未进行链表或红黑树操作,因为后面会对这个值进行更改 6 int binCount = 0; 7 for (Node<K,V>[] tab = table;;) { 8 Node<K,V> f; int n, i, fh; 9 //如果数组为空或者长度为0,进行初始化工作 10 if (tab == null || (n = tab.length) == 0) 11 tab = initTable(); 12 //如果获取位置的节点为空,说明是首节点插入情况 13 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { 14 if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null))) 15 break;//直接在首节点插入对应元素,不用加锁 16 } 17 //如果hash值等于MOVEN(默认-1),说明是协助扩容,与transfer里面的ForwardingNode类有关 18 else if ((fh = f.hash) == MOVED) 19 tab = helpTransfer(tab, f);//协助扩容,这里就是用到transfer函数的地方 20 else { 21 V oldVal = null; 22 //对桶的首节点进行加锁 23 synchronized (f) { 24 //双重判定,为了防止在当前线程进来之前,i地址所对应对象已经更改 25 if (tabAt(tab, i) == f) { 26 //TreeBin类型的hash值默认设置为了-2 27 if (fh >= 0) { 28 binCount = 1; 29 for (Node<K,V> e = f;; ++binCount) { 30 K ek; 31 //在当前桶中找到位置跳出 32 if (e.hash == hash && 33 ((ek = e.key) == key || 34 (ek != null && key.equals(ek)))) { 35 oldVal = e.val; 36 if (!onlyIfAbsent) 37 e.val = value; 38 break; 39 } 40 Node<K,V> pred = e; 41 //当到桶的结尾还没找到,则新增一个Node 42 if ((e = e.next) == null) { 43 pred.next = new Node<K,V>(hash, key, 44 value, null); 45 break; 46 } 47 } 48 } 49 //如果hash小于0,判断是否是TreeBin的实例 50 else if (f instanceof TreeBin) { 51 Node<K,V> p; 52 binCount = 2; 53 if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, 54 value)) != null) { 55 oldVal = p.val; 56 if (!onlyIfAbsent) 57 p.val = value; 58 } 59 } 60 } 61 } 62 //如果binCount值不等于0,说明进行了链表或者红黑树操作 63 if (binCount != 0) { 64 //如果binCount大于8则进行树化,但真正的转换成红黑树不是8的长度 65 //当长度超过64才会真正的树化,处于8-64之间的还只是数组扩容 66 if (binCount >= TREEIFY_THRESHOLD) 67 //这个就是树化链表操作 68 treeifyBin(tab, i); 69 if (oldVal != null) 70 return oldVal; 71 break; 72 } 73 } 74 } 75 //计数方法 76 addCount(1L, binCount); 77 return null; 78 }
插入1对键值对时,先判断数组是否空,长度是否为0(没有就先创建1个数组),再判断数组对应表是否为空节点(没有表直接现创一个,完成后退出函数)
这个节点的hash是-1的情况(MOVEN)下,需要先进行协助扩容,再进行下一步操作
之后,在这个表上执行插入操作,如果插入之后,这个表的长度超过8,会进行下一步处理:
表数据量在8-64之间时,会优先扩容hash数组;只有表数据量超过64时,内部才会执行树化。
(防止hash表的查询时间复杂度从O(1)过快退化成O(lg n),如果不重写类比较器Compare,查询复杂度会更进一步退化为O(n))
/**********************其他函数作用的分割线
initTable()的作用,是根据sizeCtl(负数的话,就是16)这个值申请长度为sizeCtl的Node<K,V>数组,放在这个map对象里并返回,作为本对象专用hash表
tabAt(a, b)的作用,是查找a表的第b个位置,如果找不到元素则返回null,否则返回第b个位置的hash表头
casTabAt(a, b, c, d)作用是,在a表的第b个hash表头上,创建并连接元素d,如果这个hash表头在此期间被其他线程操作过,返回false;没有其他线程操作,成功,返回true
spread(n):内部运算为(n ^ n >>> 16) & Integer.MAX_VALUE,先对n的低16位进行扰动处理,然后屏蔽符号位,结果为32位int型非负数
***********************分割线完了************/
helpTransfer代码:(协助扩容,这个函数的作用会讲到)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) { Node<K,V>[] nextTab;int sc; //条件:原结点不为空,这个结点是协助结点(ForwardingNode)并且不处于最后 if (tab != null && (f instanceof ForwardingNode) && (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) { int rs = resizeStamp(tab.length); //sizeCtl是负数,标明还在扩容;tab和现在占用的table不同,说明扩容还在进行当中 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)) { transfer(tab, nextTab); break; } } return nextTab; } return table; } helpTransfer(Node<K,V>[] tab, Node<K,V> f)
这一层需要使用transfer扩容
/**********************其他函数作用的分割线
resizeStamp(n):返回结果是32768+Integer.numberOfLeadingZeros(n),是否扩容的标记
***********************分割线完了************/
上面还有一个函数addCount,内部操作也会扩容(感谢swenfang作者)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//check -1是删除,1是链表,2是红黑树 private final void addCount(long x, int check) { CounterCell[] as; long b, s; //利用CAS方法更新 baseCount 的值 if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {// 1 CounterCell a; long v; int m; boolean uncontended = true; if (as == null || (m = as.length - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null || !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) { // 多线程修改baseCount时,竞争失败的线程会执行fullAddCount(x, uncontended),把x的值插入到counterCell类中 fullAddCount(x, uncontended); // 2 return; } if (check <= 1)//这里添加之后,不是树就不用操作了 return; s = sumCount(); } //如果check值大于等于0 则需要检验是否需要进行扩容操作 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); // 如果小于0 说明已经有线程在进行扩容了 if (sc < 0) { // 以下的情况说明已经有在扩容或者多线程进行了扩容,其他线程直接 break 不要进入扩容 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); } // 当前线程是唯一的或是第一个发起扩容的线程 此时nextTable=null else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)) transfer(tab, null); s = sumCount(); } } }
看上面的注释1,每次都会对 baseCount 加1,如果并发竞争太大,可能导致 U.compareAndSwapLong(this,BASECOUNT,b=baseCount,s = b + x) 失败,为了提高高并发的时候 baseCount 可见性的失败的问题,又避免一直重试,这样性能会有很大的影响,直接用fullAddCount函数完成整个过程
2.putAll操作(批量插入键值对)
putAll操作代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 public void putAll(final Map<? extends K, ? extends V> map) { 2 this.tryPresize(map.size());//预先对表计算容量,防止重复扩容 3 for (final Map.Entry<? extends K, ? extends V> entry : map.entrySet()) { 4 this.putVal(entry.getKey(), (V)entry.getValue(), false); 5 } 6 }
putAll函数要合并一整个集合,在预先丈量容量的过程就会发生扩容,防止重复操作
tryPresize操作代码(感谢简书):
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 private final void tryPresize(int size) { 2 //计算扩容的目标size 3 // 给定的容量若>=MAXIMUM_CAPACITY的一半,直接扩容到允许的最大值,否则调用函数扩容 4 int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : 5 tableSizeFor(size + (size >>> 1) + 1); 6 int sc; 7 while ((sc = sizeCtl) >= 0) { //没有正在初始化或扩容,或者说表还没有被初始化 8 Node<K,V>[] tab = table; int n; 9 //tab没有初始化 10 if(tab == null || (n = tab.length) == 0) { 11 n = (sc > c) ? sc : c; // 扩容阀值取较大者 12 //期间没有其他线程对表操作,则CAS将SIZECTL状态置为-1,表示正在进行初始化 13 //初始化之前,CAS设置sizeCtl=-1 14 if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { 15 try { 16 if (table == tab) { 17 @SuppressWarnings("unchecked") 18 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; 19 table = nt; 20 sc = n - (n >>> 2); //sc=0.75n,相当于扩容阈值 21 } 22 } finally { 23 // 此时并没有通过CAS赋值,因为其他想要执行初始化的线程, 24 // 发现sizeCtl=-1,就直接返回,从而确保任何情况, 25 // 只会有一个线程执行初始化操作。 26 sizeCtl = sc; 27 } 28 } 29 } 30 // 若欲扩容值不大于原阀值,或现有容量>=最值,什么都不用做了 31 //目标扩容size小于扩容阈值,或者容量超过最大限制时,不需要扩容 32 else if (c <= sc || n >= MAXIMUM_CAPACITY) 33 break; 34 //扩容 35 else if (tab == table) { 36 int rs = resizeStamp(n); 37 // sc<0表示,已经有其他线程正在扩容 38 if (sc < 0) { 39 Node<K,V>[] nt; 40 // RESIZE_STAMP_SHIFT=16,MAX_RESIZERS=2^15-1 41 // 1. (sc >>> RESIZE_STAMP_SHIFT) != rs :扩容线程数 > MAX_RESIZERS-1 42 // 2. sc == rs + 1 和 sc == rs + MAX_RESIZERS :表示什么??? 43 // 3. (nt = nextTable) == null :表示nextTable正在初始化 44 // transferIndex <= 0 :表示所有hash桶均分配出去 45 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || 46 sc == rs + MAX_RESIZERS || (nt = nextTable) == null || 47 transferIndex <= 0) 48 //如果不需要帮其扩容,直接返回 49 break; 50 //CAS设置sizeCtl=sizeCtl+1 51 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) 52 //帮其扩容 53 transfer(tab, nt); 54 } 55 // 第一个执行扩容操作的线程,将sizeCtl设置为: 56 // (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2) 57 else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)) 58 transfer(tab, null); 59 } 60 } 61 }
在数组没有初始化的情况下,tryPresize会开动初始化程序,sizeCtl(扩容阈值)设置-1,表示正在初始化。
不满足扩容条件(未达阈值,或者超过容量限制)不扩容,退出函数
满足扩容条件,如果所有的表都在扩容,或者线程过多,就退出函数;否则协助扩容。
并且扩容操作会多次执行,直到无需扩容为止
/**********************其他函数作用的分割线
tableSizeFor(n):n向上取整2的整数次方,若n是5,本身不是2的整数次方,但是向上有最近的8是2的整数次方,返回8;若n是4,本身就是2的整数次方,返回4
***********************分割线完了************/
putVal部分与第1个情况一致
3.remove操作(移除元素,底层实现是用null空值代替原位元素)
remove操作代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 public boolean remove(final Object o, final Object o2) { 2 if (o == null) { 3 throw new NullPointerException(); 4 } 5 return o2 != null && this.replaceNode(o, null, o2) != null; 6 }
主要是replaceNode这里可能涉及协助扩容
replaceNode操作代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 final V replaceNode(Object key, V value, Object cv) { 2 int hash = spread(key.hashCode()); 3 for (Node<K,V>[] tab = table;;) { 4 Node<K,V> f; int n, i, fh; 5 // table 还没初始化或key对应的 hash 桶为空 6 if (tab == null || (n = tab.length) == 0 || 7 (f = tabAt(tab, i = (n - 1) & hash)) == null) 8 break; 9 // 正在扩容 10 else if ((fh = f.hash) == MOVED) 11 tab = helpTransfer(tab, f); 12 else { 13 V oldVal = null; 14 boolean validated = false; 15 synchronized (f) { 16 // CAS 获取 tab[i] ,如果此时 tab[i] != f,说明其他线程修改了 tab[i] 17 // 回到 for 循环开始处,重新执行 18 if (tabAt(tab, i) == f) { 19 // node 链表 20 if (fh >= 0) { 21 validated = true; 22 for (Node<K,V> e = f, pred = null;;) { 23 K ek; 24 if (e.hash == hash && 25 ((ek = e.key) == key || 26 (ek != null && key.equals(ek)))) { 27 V ev = e.val; 28 // ev 代表参数期望值 29 // cv == null:直接更新value/删除节点 30 // cv 不为空,则只有在 key 的 oldVal 等于 31 // 期望值的时候,才更新 value/删除节点 32 if (cv == null || cv == ev || 33 (ev != null && cv.equals(ev))) { 34 oldVal = ev; 35 //更新value 36 if (value != null) 37 e.val = value; 38 //删除非头节点 39 else if (pred != null) 40 pred.next = e.next; 41 //删除头节点 42 else 43 // 因为已经获取了头结点锁,所以此时 44 // 不需要使用casTabAt 45 setTabAt(tab, i, e.next); 46 } 47 break; 48 } 49 //当前节点不是目标节点,继续遍历下一个节点 50 pred = e; 51 if ((e = e.next) == null) 52 //到达链表尾部,依旧没有找到,跳出循环 53 break; 54 } 55 } 56 //红黑树 57 else if (f instanceof TreeBin) { 58 validated = true; 59 TreeBin<K,V> t = (TreeBin<K,V>)f; 60 TreeNode<K,V> r, p; 61 if ((r = t.root) != null && 62 (p = r.findTreeNode(hash, key, null)) != null) { 63 V pv = p.val; 64 if (cv == null || cv == pv || 65 (pv != null && cv.equals(pv))) { 66 oldVal = pv; 67 if (value != null) 68 p.val = value; 69 else if (t.removeTreeNode(p)) 70 setTabAt(tab, i, untreeify(t.first)); 71 } 72 } 73 } 74 } 75 } 76 if (validated) { 77 if (oldVal != null) { 78 //如果删除了节点,更新size 79 if (value == null) 80 addCount(-1L, -1); 81 return oldVal; 82 } 83 break; 84 } 85 } 86 } 87 return null; 88 }
如果插入的表正好需要扩容,则开动transfer()协助扩容
在这之后,再对值进行替换,是空值的话,会删除旧值
如果发生了删除操作,在之后会执行addCount(-1L, -1);计数器减1
/**********************其他函数作用的分割线
setTabAt(tab, i, node):将tab表的第b个hash表头设成node
***********************分割线完了************/
4.replace操作(对已存在的键值对替换值)
两个参数的replace操作,返回替换出来的值:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public V replace(final K k, final V v) { if (k == null || v == null) { throw new NullPointerException(); } return this.replaceNode(k, v, null); }
三个参数的replace操作,第三个参数是对照值,返回值是布尔值,取决于键对应的键值对是否存在,以及是否替换成功(如果原键值对的值和对照值不同则不替换)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public boolean replace(final K k, final V v, final V v2) { if (k == null || v == null || v2 == null) { throw new NullPointerException(); } return this.replaceNode(k, v2, v) != null; }
这俩函数下一层也是replaceNode
5.computeIfAbsent操作(若key对应的value为空,会将第二个参数的返回值存入并返回)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 public V computeIfAbsent(final K k, final Function<? super K, ? extends V> function) { 2 if (k == null || function == null) { 3 throw new NullPointerException(); 4 } 5 final int spread = spread(k.hashCode()); 6 Object o = null; 7 int n = 0; 8 Object[] array = this.table; 9 while (true) { 10 final int length; 11 //数组没有初始化,初始化一个先 12 if (array == null || (length = ((Node<K, V>[])array).length) == 0) { 13 array = this.initTable(); 14 } 15 else { 16 final int n2; 17 final Map.Entry<K, V> tab; 18 //查的对应hash表没有数据,直接function.apply(k)创建一份值 19 if ((tab = (Map.Entry<K, V>)tabAt((Node<K, V>[])array, n2 = (length - 1 & spread))) == null) { 20 final ReservationNode<Object, Object> reservationNode = new ReservationNode<Object, Object>(); 21 synchronized (reservationNode) { 22 if (casTabAt((Node<K, V>[])array, n2, null, (Node<K, V>)reservationNode)) { 23 n = 1; 24 Node<Object, Object> node = null; 25 try { 26 if ((o = function.apply(k)) != null) { 27 node = new Node<Object, Object>(spread, k, o, null); 28 } 29 } 30 finally { 31 setTabAt((Node<K, V>[])array, n2, (Node<K, V>)node); 32 } 33 } 34 } 35 if (n != 0) { 36 break; 37 } 38 continue; 39 } 40 //查的对应hash表有数据 41 else { 42 final int hash; 43 //对应hash表-1,协助扩容 44 if ((hash = ((Node)tab).hash) == -1) { 45 array = this.helpTransfer((Node<K, V>[])array, (Node<K, V>)tab); 46 } 47 else { 48 boolean b = false; 49 synchronized (tab) { 50 Label_0433: { 51 //表没有发生变化就可以操作,否则就是被占用了 52 if (tabAt((Node<K, V>[])array, n2) == tab) { 53 //链表 54 if (hash >= 0) { 55 n = 1; 56 Node<K, V> next = (Node<K, V>)tab; 57 K key; 58 while (next.hash != spread || ((key = next.key) != k && (key == null || !k.equals(key)))) { 59 final Node<K, V> node2 = next; 60 if ((next = next.next) == null) { 61 if ((o = function.apply(k)) != null) { 62 b = true; 63 node2.next = (Node<K, V>)new Node<Object, Object>(spread, (K)k, (V)o, null); 64 } 65 break Label_0433; 66 } 67 ++n; 68 } 69 o = next.val; 70 } 71 //红黑树 72 else if (tab instanceof TreeBin) { 73 n = 2; 74 final TreeBin treeBin = (TreeBin)tab; 75 final Object root; 76 final TreeNode<K, Object> treeNode; 77 if ((root = treeBin.root) != null && (treeNode = ((TreeNode<K, Object>)root).findTreeNode(spread, k, null)) != null) { 78 o = treeNode.val; 79 } 80 else if ((o = function.apply(k)) != null) { 81 b = true; 82 treeBin.putTreeVal(spread, k, o); 83 } 84 } 85 } 86 } 87 } 88 if (n == 0) { 89 continue; 90 } 91 if (n >= 8) { 92 this.treeifyBin((Node<K, V>[])array, n2); 93 } 94 //上述b为是否找不到元素 95 if (!b) { 96 return (V)o; 97 } 98 break; 99 } 100 } 101 } 102 } 103 //上一个操作中,hash值能对应表,并且找到值之后就返回了 104 //这里只有找不到值,需要重赋值才执行到 105 if (o != null) { 106 this.addCount(1L, n); 107 } 108 return (V)o; 109 }
这里网上找不到代码,用rt.jar反编译的代码代替
如果找到的表预备扩容,会先执行helpTransfer
在此之后,如果是添加元素而非单纯的查找元素,就会执行addCount操作,这俩操作都会扩容
扩容的内部逻辑
读了一下transfer代码,了解了很多东西。
首先是为什么初始容量必须为2的整数次方,并且扩容是2倍2倍地扩:使扩容前的单个节点无需与其他节点交互,只控制自己的节点和跳过去的新节点。
例如hash表有8个,要扩容为16个,那么之前放在7表的数据,可能对16取模会余15,也可能还是7;其他7种元素只能分配到7和15以外的0-15余数;这样的话,只需把部分数据往15表上移,保留一部分到原表中。
并且数程序会仔细判定数据的插入顺序,这使得原来数据的插入顺序扩容之后不会打乱。
再者还有为什么有ForwardingNode和helpTransfer():单个扩容线程的扩容速度会很慢,可能有线程需要插入尾端数据,但是那个扩容线程在头端。这样的话,给对应hash表设置灵活的扩容机制比较重要。读线程不需修改数据,直接把数据读了就是;写线程要考虑新插入的数据位置,让这个线程协助扩容,再完成插入操作的话这个线程的写操作不会堵塞很久。
这就是ForwardingNode节点和helpTransfer()的作用。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) { 2 int n = tab.length, stride; 3 //计算每次迁移的node个数(MIN_TRANSFER_STRIDE该值作为下限,以避免扩容线程过多) 4 if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) 5 // 确保每次迁移的node个数不少于16个 6 stride = MIN_TRANSFER_STRIDE; 7 // nextTab为扩容中的临时table 8 if (nextTab == null) { 9 try { 10 //扩容一倍 11 @SuppressWarnings("unchecked") 12 // 1. 新建一个 node 数组,容量为之前的两倍 13 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; 14 nextTab = nt; 15 } catch (Throwable ex) { // try to copy with OOME 16 sizeCtl = Integer.MAX_VALUE; 17 return; 18 } 19 nextTable = nextTab; 20 // transferIndex为扩容复制过程中的桶首节点遍历索引 21 // 所以从n开始,表示从后向前遍历 22 transferIndex = n; 23 } 24 int nextn = nextTab.length; 25 // ForwardingNode是Node节点的直接子类,是扩容过程中的特殊桶首节点 26 // 该类中没有key,value,next 27 // hash值为特定的-1 28 // 附加Node<K,V>[] nextTable变量指向扩容中的nextTab 29 // 在find方法中,将扩容中的查询操作导入到nextTab上 30 //2. 新建forwardingNode引用,在之后会用到 31 ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab); 32 boolean advance = true; 33 // 循环的关键变量,判断是否已经扩容完成,完成就 return , 退出循环 34 boolean finishing = false; 35 //【1】逆序迁移已经获取到的hash桶集合,如果迁移完毕,则更新transferIndex, 36 // 获取下一批待迁移的hash桶 37 //【2】如果transferIndex=0,表示所以hash桶均被分配,将i置为-1, 38 // 准备退出transfer方法 39 for (int i = 0, bound = 0;;) { 40 Node<K,V> f; int fh; 41 // 3. 确定遍历中的索引i(更新待迁移的hash桶索引) 42 // 循环的关键 i , i-- 操作保证了倒叙遍历数组 43 while (advance) { 44 int nextIndex, nextBound; 45 // 更新迁移索引i 46 if (--i >= bound || finishing) 47 advance = false; 48 // transferIndex = 0表示table中所有数组元素都已经有其他线程负责扩容 49 // nextIndex=transferIndex=n=tab.length(默认16) 50 else if ((nextIndex = transferIndex) <= 0) { 51 // transferIndex<=0表示已经没有需要迁移的hash桶, 52 // 将i置为-1,线程准备退出 53 i = -1; 54 advance = false; 55 } 56 //cas无锁算法设置 transferIndex = transferIndex - stride 57 // 尝试更新transferIndex,获取当前线程执行扩容复制的索引区间 58 // 更新成功,则当前线程负责完成索引为(nextBound,nextIndex)之间的桶首节点扩容 59 //当迁移完bound这个桶后,尝试更新transferIndex,获取下一批待迁移的hash桶 60 else if (U.compareAndSwapInt 61 (this, TRANSFERINDEX, nextIndex, 62 nextBound = (nextIndex > stride ? 63 nextIndex - stride : 0))) { 64 bound = nextBound; 65 i = nextIndex - 1; 66 advance = false; 67 } 68 } //退出transfer 69 //4.将原数组中的元素复制到新数组中去 70 //4.5 for循环退出,扩容结束修改sizeCtl属性 71 // i<0 说明已经遍历完旧的数组tab;i>=n什么时候有可能呢?在下面看到i=n,所以目前i最大应该是n吧 72 // i+n>=nextn,nextn=nextTab.length,所以如果满足i+n>=nextn说明已经扩容完成 73 if (i < 0 || i >= n || i + n >= nextn) { 74 int sc; 75 if (finishing) { // a 76 //最后一个迁移的线程,recheck后,做收尾工作,然后退出 77 nextTable = null; 78 table = nextTab; 79 // 扩容成功,设置新sizeCtl,仍然为总大小的0.75 80 sizeCtl = (n << 1) - (n >>> 1); 81 return; 82 } 83 84 // 第一个扩容的线程,执行transfer方法之前,会设置 sizeCtl = 85 // (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2) 86 // 后续帮其扩容的线程,执行transfer方法之前,会设置 sizeCtl = sizeCtl+1 87 // 每一个退出transfer的方法的线程,退出之前,会设置 sizeCtl = sizeCtl-1 88 // 那么最后一个线程退出时: 89 // 必然有sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2), 90 // 即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT 91 92 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { 93 // 如果有多个线程进行扩容,那么这个值在第二个线程以后就不会相等,因为 94 // sizeCtl 已经被减1了,所以后面的线程只能直接返回, 95 // 始终保证只有一个线程执行了a(上面的注释a) 96 if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) 97 return; 98 // finishing 和 advance 保证线程已经扩容完成了可以退出循环 99 finishing = advance = true; 100 //最后退出的线程要重新check下是否全部迁移完毕 101 i = n; 102 } 103 } 104 // 当前table节点为空,不需要复制,直接放入ForwardingNode 105 //4.1 当前数组中第i个元素为null,用CAS设置成特殊节点forwardingNode(可以理解成占位符) 106 //如果 tab[i] 为 null,那么就把 fwd 插入到 tab[i],表明这个节点已经处理过了 107 else if ((f = tabAt(tab, i)) == null) 108 advance = casTabAt(tab, i, null, fwd); 109 // 当前table节点已经是ForwardingNode 110 // 表示已经被其他线程处理了,则直接往前遍历 111 // 通过CAS读写ForwardingNode节点状态,达到多线程互斥处理 112 // 4.2 如果遍历到ForwardingNode节点说明这个点已经被处理过了直接跳过 113 // 这里是控制并发扩容的核心 114 // 如果 f.hash=-1 的话说明该节点为 ForwardingNode,说明该节点已经处理过了 115 else if ((fh = f.hash) == MOVED) 116 advance = true; 117 //迁移node节点 118 else { 119 // 锁住当前桶首节点 120 synchronized (f) { 121 if (tabAt(tab, i) == f) { 122 Node<K,V> ln, hn; 123 // 链表节点复制(链表迁移) 124 if (fh >= 0) { 125 // 4.3 处理当前节点为链表的头结点的情况,构造两个链表,一个是原链表 126 // 另一个是原链表的反序排列 127 int runBit = fh & n; 128 Node<K,V> lastRun = f; 129 //将node链表,分成2个新的node链表 130 // 这边还对链表进行遍历,这边的算法和hashMap的算法又不一样了,对半拆分 131 // 把链表拆分为,hash&n 等于0和不等于0的,然后分别放在新表的i和i+n位置 132 // 此方法同 HashMap 的 resize 133 for (Node<K,V> p = f.next; p != null; p = p.next) { 134 int b = p.hash & n; 135 if (b != runBit) { 136 runBit = b; 137 lastRun = p; 138 } 139 } 140 if (runBit == 0) { 141 ln = lastRun; 142 hn = null; 143 } 144 else { 145 hn = lastRun; 146 ln = null; 147 } 148 for (Node<K,V> p = f; p != lastRun; p = p.next) { 149 int ph = p.hash; K pk = p.key; V pv = p.val; 150 if ((ph & n) == 0) 151 ln = new Node<K,V>(ph, pk, pv, ln); 152 else 153 hn = new Node<K,V>(ph, pk, pv, hn); 154 } 155 //将新node链表赋给nextTab 156 //在nextTable的i位置上插入一个链表 157 setTabAt(nextTab, i, ln); 158 //在nextTable的i+n的位置上插入另一个链表 159 setTabAt(nextTab, i + n, hn); 160 // 扩容成功后,设置ForwardingNode节点 161 //在table的i位置上插入forwardNode节点表示已经处理过该节点 162 // 把已经替换的节点的旧tab的i的位置用fwd替换,fwd包含nextTab 163 setTabAt(tab, i, fwd); 164 //设置advance为true 返回到上面的while循环中 就可以执行i--操作 165 advance = true; 166 } 167 // 红黑树节点复制(红黑树迁移) 168 //4.4 处理当前节点是TreeBin时的情况,操作和上面的类似 169 else if (f instanceof TreeBin) { 170 TreeBin<K,V> t = (TreeBin<K,V>)f; 171 TreeNode<K,V> lo = null, loTail = null; 172 TreeNode<K,V> hi = null, hiTail = null; 173 int lc = 0, hc = 0; 174 for (Node<K,V> e = t.first; e != null; e = e.next) { 175 int h = e.hash; 176 TreeNode<K,V> p = new TreeNode<K,V> 177 (h, e.key, e.val, null, null); 178 //可看出本节点扩容之后应该放低位节点 179 if ((h & n) == 0) { 180 if ((p.prev = loTail) == null) 181 lo = p; 182 else 183 loTail.next = p; 184 loTail = p; 185 ++lc; 186 } 187 //扩容之后应该放高位节点 188 else { 189 if ((p.prev = hiTail) == null) 190 hi = p; 191 else 192 hiTail.next = p; 193 hiTail = p; 194 ++hc; 195 } 196 } 197 // 判断扩容后是否还需要红黑树 198 ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : 199 (hc != 0) ? new TreeBin<K,V>(lo) : t; 200 hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : 201 (lc != 0) ? new TreeBin<K,V>(hi) : t; 202 setTabAt(nextTab, i, ln); 203 setTabAt(nextTab, i + n, hn); 204 // 扩容成功后,设置ForwardingNode节点 205 setTabAt(tab, i, fwd); 206 advance = true; 207 } 208 } 209 } 210 } 211 } 212 }