static final int resizeStamp(int n) { return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1)); }

U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)

• 1. 首先在 CHM 中是支持并发扩容的，也就是说如果当前的数组需要进行扩容操作，可以由多个线程来共同负责，这块后续会单独讲
• 2. 可以保证每次扩容都生成唯一的生成戳，每次新的扩容，都有一个不同的 n，这个生成戳就是根据 n 来计算出来的一个数字，n 不同，这个数字也不同

private final void transfer(Node[] tab, Node[] nextTab) { int n = tab.length, stride; //将 (n>>>3 相当于 n/8) 然后除以 CPU 核心数。如果得到的结果小于 16，那么就使用 16 // 这里的目的是让每个 CPU 处理的桶一样多，避免出现转移任务不均匀的现象，如果桶较少的话， //默认一个 CPU（一个线程）处理 16 个桶，也就是长度为 16 的时候，扩容的时候只会有一个线程来扩容 if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) stride = MIN_TRANSFER_STRIDE; // subdivide range //nextTab 未初始化，nextTab 是用来扩容的 node 数组 if (nextTab == null) { // initiating try { @SuppressWarnings("unchecked") //新建一个 n<<1 原始 table 大小的 nextTab,也就是 32 Node[] nt = (Node[]) new Node[n << 1]; nextTab = nt; //赋值给 nextTab } catch (Throwable ex) { // try to cope with OOME sizeCtl = Integer.MAX_VALUE; //扩容失败，sizeCtl 使用 int 的最大值 return; } nextTable = nextTab; //更新成员变量 transferIndex = n; //更新转移下标，表示转移时的下标 } int nextn = nextTab.length; //新的 tab 的长度 //创建一个 fwd 节点，表示一个正在被迁移的 Node，并且它的 hash 值为-1(MOVED)， //也就是前面我们在讲 putval 方法的时候，会有一个判断 MOVED 的逻辑。它的作用是用来占位， //表示原数组中位置 i 处的节点完成迁移以后，就会在 i 位置设置一个 fwd 来告诉其他线程这个位置已经处理过了 ForwardingNode fwd = new ForwardingNode(nextTab); // 首次推进为 true，如果等于 true，说明需要再次推进一个下标（i--），反之，如果是false， // 那么就不能推进下标，需要将当前的下标处理完毕才能继续推进 boolean advance = true; //判断是否已经扩容完成，完成就 return，退出循环 boolean finishing = false; // to ensure sweep before committing nextTab //通过 for 自循环处理每个槽位中的链表元素，默认 advace 为真，通过 CAS 设置 //transferIndex 属性值，并初始化 i 和 bound 值，i 指当前处理的槽位序号， //bound 指需要处理的槽位边界，先处理槽位 15 的节点； for (int i = 0, bound = 0; ; ) { // 这个循环使用 CAS 不断尝试为当前线程分配任务 // 直到分配成功或任务队列已经被全部分配完毕 // 如果当前线程已经被分配过 bucket 区域 // 那么会通过--i 指向下一个待处理 bucket 然后退出该循环 Node f; int fh; while (advance) { int nextIndex, nextBound; //--i 表示下一个待处理的 bucket，如果它>=bound,表示当前线程已经分配过bucket 区域 if (--i >= bound || finishing) advance = false; else if ((nextIndex = transferIndex) <= 0) {//表示所有 bucket 已经被分配完毕 i = -1; advance = false; } //通过 cas 来修改 TRANSFERINDEX,为当前线程分配任务，处理的节点区间为(nextBound,nextIndex)->(0,15) else if (U.compareAndSwapInt (this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) { bound = nextBound; //0 i = nextIndex - 1; //15 advance = false; } } //i<0 说明已经遍历完旧的数组，也就是当前线程已经处理完所有负责的 bucket if (i < 0 || i >= n || i + n >= nextn) { int sc; if (finishing) {//如果完成了扩容 nextTable = null; //删除成员变量 table = nextTab; //更新 table 数组 sizeCtl = (n << 1) - (n >>> 1); //更新阈值(32*0.75=24) return; } // sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2 // 然后，每增加一个线程参与迁移就会将 sizeCtl 加 1， // 这里使用 CAS 操作对 sizeCtl 的低 16 位进行减 1，代表做完了属于自己的任务 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { /* 第一个扩容的线程，执行 transfer 方法之前，会设置 sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2) 后续帮其扩容的线程，执行 transfer 方法之前，会设置 sizeCtl = sizeCtl+1 每一个退出 transfer 的方法的线程，退出之前，会设置 sizeCtl = sizeCtl-1 那么最后一个线程退出时：必然有 sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT 如果 sc - 2 不等于标识符左移 16 位。如果他们相等了，说明没有线程在帮助他们扩容了。也就是说，扩容结束了。 */ 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); //表示该位置已经完成了迁移，也就是如果线程 A 已经处理过这个节点，那么线程 B 处理这个节点时，hash 值一定为 MOVED else if ((fh = f.hash) == MOVED) advance = true; // already processed else{//这里是数据迁移的代码，目前先省略，接下来会详细分析 synchronized (f) {//对数组该节点位置加锁，开始处理数组该位置的迁移工作 if (tabAt(tab, i) == f) { ... } } } } }

if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)

synchronized (f) {//对数组该节点位置加锁，开始处理数组该位置的迁移工作 if (tabAt(tab, i) == f) {//再做一次校验 Node ln, hn; //ln 表示低位， hn 表示高位; 接下来这段代码的作用是把链表拆分成两部分，0 在低位，1 在高位 if (fh >= 0) {//下面部分代码原理点击这里 int runBit = fh & n; Node lastRun = f; //遍历当前 bucket 的链表，目的是尽量重用 Node 链表尾部的一部分 for (Node p = f.next; p != null; p = p.next) { int b = p.hash & n; if (b != runBit) { runBit = b; lastRun = p; } } if (runBit == 0) { //如果最后更新的 runBit 是 0，设置低位节点 ln = lastRun; hn = null; } else {//否则，设置高位节点 hn = lastRun; ln = null; } //构造高位以及低位的链表 for (Node 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(ph, pk, pv, ln); else hn = new Node(ph, pk, pv, hn); } setTabAt(nextTab, i, ln); //将低位的链表放在 i 位置也就是不动 setTabAt(nextTab, i + n, hn); //将高位链表放在 i+n 位置 setTabAt(tab, i, fwd); // 把旧 table 的 hash 桶中放置转发节点，表明此 hash 桶已经被处理 advance = true; } //红黑树的扩容部分暂时忽略 } }

1. 如何实现高低位链表的区分
   假如我们有这样一个队列
   
   
   文章图片
   image.png

for (Node p = f.next; p != null; p = p.next) { int b = p.hash & n; if (b != runBit) { runBit = b; lastRun = p; } }

for (Node 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(ph, pk, pv, ln); else hn = new Node(ph, pk, pv, hn); }

setTabAt(nextTab, i, ln); setTabAt(nextTab, i + n, hn); setTabAt(tab, i, fwd);

//i<0 说明已经遍历完旧的数组，也就是当前线程已经处理完所有负责的 bucket if (i < 0 || i >= n || i + n >= nextn) { int sc; if (finishing) {//如果完成了扩容 nextTable = null; //删除成员变量 table = nextTab; //更新 table 数组 sizeCtl = (n << 1) - (n >>> 1); //更新阈值(32*0.75=24) return; } // sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2 // 然后，每增加一个线程参与迁移就会将 sizeCtl 加 1， // 这里使用 CAS 操作对 sizeCtl 的低 16 位进行减 1，代表做完了属于自己的任务 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { /* 第一个扩容的线程，执行 transfer 方法之前，会设置 sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2) 后续帮其扩容的线程，执行 transfer 方法之前，会设置 sizeCtl = sizeCtl+1 每一个退出 transfer 的方法的线程，退出之前，会设置 sizeCtl = sizeCtl-1 那么最后一个线程退出时：必然有 sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT 如果 sc - 2 不等于标识符左移 16 位。如果他们相等了，说明没有线程在帮助他们扩容了。也就是说，扩容结束了。 */ if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) return; // 如果相等，扩容结束了，更新 finising 变量 finishing = advance = true; // 再次循环检查一下整张表 i = n; // recheck before commit } }

else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f);

final Node[] helpTransfer(Node[] tab, Node f) { Node[] nextTab; int sc; // 判断此时是否仍然在执行扩容,nextTab=null 的时候说明扩容已经结束了 if (tab != null && (f instanceof ForwardingNode) && (nextTab = ((ForwardingNode)f).nextTable) != null) { int rs = resizeStamp(tab.length); //生成扩容戳 while (nextTab == nextTable && table == tab && (sc = sizeCtl) < 0) {//说明扩容还未完成的情况下不断循环来尝试将当前线程加入到扩容操作中 //下面部分的整个代码表示扩容结束，直接退出循环 //transferIndex<=0 表示所有的 Node 都已经分配了线程 //sc=rs+MAX_RESIZERS 表示扩容线程数达到最大扩容线程数 //sc >>> RESIZE_STAMP_SHIFT !=rs， 如果在同一轮扩容中，那么 sc 无符号 //右移比较高位和 rs 的值，那么应该是相等的。如果不相等，说明扩容结束了 //sc==rs+1 表示扩容结束 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || transferIndex <= 0) break; //跳出循环 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {//在低 16 位上增加扩容线程数 transfer(tab, nextTab); //帮助扩容 break; } } return nextTab; } return table; //返回新的数组 }

final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value =https://www.it610.com/article/= null) throw new NullPointerException(); int hash = spread(key.hashCode()); int binCount = 0; for (ConcurrentHashMap.Node[] tab = table; ; ) { ConcurrentHashMap.Node f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); //put 方法第一阶段 else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { if (casTabAt(tab, i, null, new ConcurrentHashMap.Node(hash, key, value, null))) break; // no lock when adding to empty bin } else if ((fh = f.hash) == MOVED)//put 方法第三阶段 tab = helpTransfer(tab, f); else { //put 方法第四阶段,进入到这个分支，说明 f 是当前 nodes 数组对应位置节点的头节点，并且不为空 V oldVal = null; synchronized (f) { //给对应的头结点加锁 if (tabAt(tab, i) == f) {//再次判断对应下标位置是否为 f 节点 if (fh >= 0) { //头结点的 hash 值大于 0，说明是链表 binCount = 1; //用来记录链表的长度 for (Node e = f; ; ++binCount) {//遍历链表 K ek; //如果发现相同的 key，则判断是否需要进行值的覆盖 if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { oldVal = e.val; if (!onlyIfAbsent) //默认情况下，直接覆盖旧的值 e.val = value; break; } //一直遍历到链表的最末端，直接把新的值加入到链表的最后面 Node pred = e; if ((e = e.next) == null) { pred.next = new Node(hash, key, value, null); break; } } } //如果当前的 f 节点是一颗红黑树 else if (f instanceof TreeBin) { Node p; binCount = 2; //则调用红黑树的插入方法插入新的值 if ((p = ((TreeBin) 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)//如果 val 是被替换的，则返回替换之前的值 return oldVal; break; } } //put 方法第二阶段 addCount(1L, binCount); return null; } }

if (binCount != 0) {//说明上面在做链表操作 //如果链表长度已经达到临界值 8 就需要把链表转换为树结构 if (binCount >= TREEIFY_THRESHOLD) treeifyBin(tab, i); if (oldVal != null)//如果 val 是被替换的，则返回替换之前的值 return oldVal; break; }

private final void treeifyBin(Node[] tab, int index) { Node b; int n, sc; if (tab != null) { if ((n = tab.length) < MIN_TREEIFY_CAPACITY) //tab 的长度是不是小于 64，如果是，则执行扩容 tryPresize(n << 1); else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {//否则，将当前链表转化为红黑树结构存储 synchronized (b) {// 将链表转换成红黑树 if (tabAt(tab, index) == b) { TreeNode hd = null, tl = null; for (Node e = b; e != null; e = e.next) { TreeNode p = new TreeNode(e.hash, e.key, e.val, null, null); if ((p.prev = tl) == null) hd = p; else tl.next = p; tl = p; } setTabAt(tab, index, new TreeBin(hd)); } } } } }

private final void tryPresize(int size) { //对 size 进 行修复 ,主 要目 的是防 止传 入的 值不是 一个 2 次幂的 整数 ，然 后通过tableSizeFor 来讲入参转化为离该整数最近的 2 次幂 int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : tableSizeFor(size + (size >>> 1) + 1); int sc; while ((sc = sizeCtl) >= 0) { Node[] tab = table; int n; //下面这段代码和 initTable 是一样的，如果 table 没有初始化，则开始初始化 if (tab == null || (n = tab.length) == 0) { n = (sc > c) ? sc : c; if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { if (table == tab) { @SuppressWarnings("unchecked") Node[] nt = (Node[]) new Node[n]; table = nt; sc = n - (n >>> 2); //0.75 } } finally { sizeCtl = sc; } } } else if (c <= sc || n >= MAXIMUM_CAPACITY) break; else if (tab == table) {//这段代码和 addCount 后部分代码是一样的，做辅助扩容操作 int rs = resizeStamp(n); if (sc < 0) { Node[] nt; 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); } } }

/* * 相比put方法，get就很单纯了，支持并发操作， * 当key为null的时候回抛出NullPointerException的异常 * get操作通过首先计算key的hash值来确定该元素放在数组的哪个位置 * 然后遍历该位置的所有节点 * 如果不存在的话返回null */ public V get(Object key) { Node[] tab; Node e, p; int n, eh; K ek; int h = spread(key.hashCode()); if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) { if ((eh = e.hash) == h) { if ((ek = e.key) == key || (ek != null && key.equals(ek))) return e.val; } else if (eh < 0) return (p = e.find(h, key)) != null ? p.val : null; while ((e = e.next) != null) { if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek)))) return e.val; } } return null; }

推荐阅读

• 

  李锦记的蚝油哪款好吃？推荐几款好吃正宗的李锦记蚝油
• 

  子曰不患人之不己知患不知人也翻译 不患人之不己知患其不能也翻译
• 

  天麻冬菜扣肉的做法 天麻冬菜扣肉的做法窍门
• 

  “嫁”画
• 

  平板和手机互传视频，怎样将手机里的视频发到自己的平板上
• 

  车厘子发苦吃了会不会中毒
• 

  办理农村低保需要什么条件 办理农村低保需要什么条件具备
• 

  沙雕游戏是什么意思
• 

  普通皖鱼与黑皖鱼
• 

  h彻底抛弃安卓？鸿蒙OS 2.3将至，实现完全自主研发
• 

  阿胶空腹吃好还是饭后吃较好
• 

  西安公共交通失物招领平台
• 

  包头专业sap服务公司，包头专业sap服务公司电话
• 

  魔男和van 电商van是什么，van是谁
• 

  战舰世界闪击战狨怎样 战舰世界闪击战怎样参加战斗
• 

  0817(七夕祝有情人终成眷属)
• 

  核酸检测|东西城核酸检测目前仅1例阳性！北京新增病例活动轨迹
• 

  脾
• 

  word水印怎么加，word水印怎么加水印
• 

  历史上的战火为什么没有把紫禁城摧毁？

• Android事件传递源码分析
• Quartz|Quartz 源码解析(四) —— QuartzScheduler和Listener事件监听
• Java内存泄漏分析系列之二（jstack生成的Thread|Java内存泄漏分析系列之二：jstack生成的Thread Dump日志结构解析）
• [源码解析]|[源码解析] NVIDIA HugeCTR，GPU版本参数服务器---(3)
• ffmpeg源码分析01（结构体）
• Android系统启动之init.rc文件解析过程
• Java程序员阅读源码的小技巧，原来大牛都是这样读的，赶紧看看！
• 小程序有哪些低成本获客手段——案例解析
• Vue源码分析—响应式原理(二)
• SwiftUI|SwiftUI iOS 瀑布流组件之仿CollectionView不规则图文混合(教程含源码)