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; }

推荐阅读

• 

  soul网关 超时 soul网关mysql8
• 

  宝宝|新手爸妈生存图鉴：这和说好的幸福不一样啊！
• 

  ADB|ADB 使用环境
• 

  握力器一天要握多少下才能增强握力啊？
• 

  直接进入深度睡眠的方法 如何深度睡眠
• 

  电商平台股票 电商交流板块什么时候开通，电商平台概念股票
• 

  会计上的白条是什么意思
• 

  痰湿体质是怎么形成的
• 

  如何在小区开个电商 为什么不能在小区里做电商，好多电商公司都在小区
• 

  家里能养黑骨茶吗 家里为什么不能养黑骨茶
• 

  养一只德牧是一种什么样的体验？
• 

  心中最爱的自己
• 

  2021年重庆哪些地方在下雪 2023重庆黄安坝会下雪吗？
• 

  struggleing怎么读 struggle怎么读
• 

  火球uml大战需求分析
• 

  喜洋洋与灰太狼是多久出来的
• 

  离婚的真相2
• 

  多看阅读器安卓版,多看搜索结果自动保存在云服务器里
• 

  薄饼机第一次使用怎么清洗，烙饼机用完之后怎么清洗
• 

  将数据信息快速转换为表格形式

• 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不规则图文混合(教程含源码)