ConcurrentHashMap transfer分析·

清疚 2022-12-12 04:53 245阅读 0赞

文章目录

  • 前言
  • transfer初始化
  • transfer哈希桶范围确定
  • transfer 拷贝旧数据到新的哈希表
  • 参考文献

前言

本文分析1.8之下的源码。本文需要读者之前对HashMap有一定了解，如HashMap中的红黑树和链表等。

我们回顾下HashMap基本结构：

在这里插入图片描述

ConcurrentHashMap的扩容算法极其精妙，也是最晦涩难懂的部分.

我首先将代码分段梳理各个部分的功能，在做细节说明。

  1. //ConcurrentHashMap.java
  2.  private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  4.         int n = tab.length, stride;
  6.         //stride 决定一个线程处理的哈希表中多少个位置.比如为10那么处理，10个哈希桶的数据迁移工作
  7.         if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
  8.             stride = MIN_TRANSFER_STRIDE; // subdivide range
  10.         if (nextTab == null) {
  11.                 // initiating
  12.              //(1)构造一个新的数组容量为旧数据的两倍
  13.         }
  14.         int nextn = nextTab.length;
  15.         ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
  16.         boolean advance = true;
  17.         boolean finishing = false; // to ensure sweep before committing nextTab
  18.         for (int i = 0, bound = 0;;) {
  20.             Node<K,V> f; int fh;
  21.             while (advance) {
  23.                //这里作用使用确定 i和bound的数值。
  24.                //i和bound决定当前线程处理哈希表中 从i到bound位置的哈希桶拷贝到新表
  25.             }
  26.             if (i < 0 || i >= n || i + n >= nextn) {
  28.               //判断是否结束
  29.             }
  30.             else if ((f = tabAt(tab, i)) == null)
  32.                 advance = casTabAt(tab, i, null, fwd);
  33.             else if ((fh = f.hash) == MOVED)
  34.                 advance = true; 
  35.             else {
  37.                 synchronized (f) {
  39.                     if (tabAt(tab, i) == f) {
  41.                         Node<K,V> ln, hn;
  42.                         if (fh >= 0) {
  44.                            //链表哈希桶 迁移到新的扩容数组。
  45.                         }
  46.                         else if (f instanceof TreeBin) {
  48.                            //红黑树哈希桶 迁移到新的扩容数组。本文只分析链表情况
  49.                         }
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.     }

transfer初始化

此部分代码用于创建一个新的hash表，和确定每个线程处理hash表最大长度。（比如处理3个哈希桶的数据拷贝到新表）

  1. //ConcurrentHashMap.java
  2.    //forwarding nodes节点的哈希值
  3.     static final int MOVED     = -1; // hash for forwarding nodes
  5.     //仅当扩容时不为空，其他时候都为空。扩容完成自动为null
  6.     private transient volatile Node<K,V>[] nextTable;
  7.    /**
  8.     * 当扩容时nextTable分割的位置(+1)
  9.      * The next table index (plus one) to split while resizing.
  10.      */
  11.     private transient volatile int transferIndex;
  13.   //入参：tab 旧的哈希表
  14.   //入参：nextTab 要么传入ConcurrentHashMap的nextTable属性，要么和参入null。这个参数表示构造的新哈希表                
  15.   private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  17.         //旧表的长度
  18.         int n = tab.length;
  19.         //决定一个线程最大处理的哈希桶数量
  20.         int stride;
  21.         //NCPU表示cpu数量。
  22.         //MIN_TRANSFER_STRIDE 数值为16 
  23.         //(n >>> 3)表示旧表长度除以8。至于为什么要将表除以8我就不得而知，
  24.         //笔者认为是Doug Lea的实践经验除以8可以更高效。
  25.         //综上以及结合代码此处：max( 旧表长度/8/cpu数量 ,MIN_TRANSFER_STRIDE)
  26.         if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
  27.             stride = MIN_TRANSFER_STRIDE; // subdivide range
  29.         //新哈希表为空那么创建一个新的哈希表   
  30.         if (nextTab == null) {
  31.                 // initiating
  32.             try {
  34.                 //构造一个容量为旧表两倍的数组。n << 1表示为旧表长度*2 
  35.                 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
  36.                 nextTab = nt;
  37.             } catch (Throwable ex) {
  38.           // try to cope with OOME
  39.                 sizeCtl = Integer.MAX_VALUE;
  40.                 return;
  41.             }
  42.             //赋值给成员属性，防止在多线程下多次初始化
  43.             nextTable = nextTab;
  44.             //设置成员属性
  45.             transferIndex = n;
  46.         }
  47.         //新哈希表长度
  48.         int nextn = nextTab.length;
  49.         //占位节点。并且哈希值为-1，对应为成员字段MOVED
  50.         ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
  51.         //...略
  52. }

总结就是构造了一个新的哈希表并设置了最大处理长度.

transfer哈希桶范围确定

  1. //ConcurrentHashMap.java
  3.   //入参：tab 旧的哈希表
  4.   //入参：nextTab 要么传入ConcurrentHashMap的nextTable属性，要么和参入null。这个参数表示构造的新哈希表                
  5.   private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  7.         //...初始化代码略
  8.         //...
  9.         boolean advance = true;
  10.         boolean finishing = false; // to ensure sweep before committing nextTab
  11.         //for循环就是用来做旧表迁移到新表的逻辑
  12.         //死循环。直到迁移完成。i表示当前线程处理哈希桶的初始下标，bound表示当前显示线程处理哈希桶的结束下标
  13.         for (int i = 0, bound = 0;;) {
  15.             Node<K,V> f; 
  16.             int fh;
  17.             //    
  18.             while (advance) {
  20.                 int nextIndex;
  21.                 int nextBound;
  22.                 //--i的寓意 是在确定bound和i之后的下次循环才有意义
  23.                 //这里--i 是表示处理区间的下一个哈希桶元素列表，因为上次已经处理过i位置。
  24.                 if (--i >= bound || finishing)
  25.                     advance = false;
  26.                 else if ((nextIndex = transferIndex) <= 0) {
  28.                     //如果下标不合法就结束
  29.                     i = -1;
  30.                     advance = false;
  31.                 }
  32.                 //cas方式设置ConcurrentHashMap的transferIndex属性
  33.                 //transferIndex在transfer初始化阶段赋值为旧哈希表长度
  34.                 //nextIndex此时等于transferIndex。
  35.                 // nextBound = (nextIndex > stride ? nextIndex - stride : 0))
  36.                 // nextIndex > stride 如果当前分割点位置(transferIndex)大于最大处理阈值stride
  37.                 //就返回nextIndex - stride 作为处理哈希桶区间的起始下标，否则是0 
  38.                 else if (U.compareAndSwapInt
  39.                          (this, TRANSFERINDEX, nextIndex,
  40.                           nextBound = (nextIndex > stride ?
  41.                                        nextIndex - stride : 0))) {
  43.                     //确定起始下标和终止下标
  44.                     bound = nextBound;
  45.                     i = nextIndex - 1;
  46.                     advance = false;
  47.                 }
  48.             }
  49.          //...略
  50.         }//for            
  52. }

总结 ： 确定当前要处理哪部分哈希桶.bound起始坐标，i结束坐标。

transfer 拷贝旧数据到新的哈希表

  1. private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  4.         //...
  5.         //..初始化新的哈希表
  6.         //略
  7.         //固定哈希值为MOVE，用于标识正在扩容
  8.         ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
  10.         //此for循环用于拷贝旧哈希表数据到新的哈希表
  11.         for (int i = 0, bound = 0;;) {
  14.                     Node<K,V> f; 
  16.                     int fh;
  18.                     while (advance) {
  20.                        //确定bound和i数值 然后 advance=false 略
  21.                     }
  22.                     //i < 0 数据不合法
  23.                     // i >= n 当前处理的范围大于旧链表最大长度，已经不需要拷贝越界数据
  24.                     // i + n >= nextn 。nextn表示新哈希表长度，如果当前长度超过新哈希表长度，
  25.                     //证明是不合法的
  26.                     if (i < 0 || i >= n || i + n >= nextn) {
  28.                         int sc;
  29.                         if (finishing) {
  31.                             nextTable = null;
  32.                             table = nextTab;
  33.                             sizeCtl = (n << 1) - (n >>> 1);
  34.                             return;
  35.                         }
  36.                         if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
  38.                             if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
  39.                                 return;
  40.                             finishing = advance = true;
  41.                             i = n; // recheck before commit
  42.                         }
  43.                     }
  44.                     //如果旧的哈希表第i个位置不存在元素那么，放置一个fwd对象，且hash值为MOVED
  45.                     //可以让其他插入线程感知
  46.                     else if ((f = tabAt(tab, i)) == null)
  47.                         advance = casTabAt(tab, i, null, fwd);
  48.                     else if ((fh = f.hash) == MOVED)
  49.                         //当前位置已经被其他线程替换成fwd对象，那么重新拷贝其他哈希桶位置到新哈希表
  50.                         //advance标志为true 让其重新选择哈希桶拷贝到新哈希表
  51.                         advance = true; // already processed
  52.                     else {
  54.                     //else负责移动哈希桶元素到新的哈希表
  56.                         //所有哈希桶移动删除必须加锁头节点
  57.                         synchronized (f) {
  59.                             //需要二次判断 当前哈希桶头结点是否改变，因为在获取到锁时
  60.                             //哈希桶头结点已经改变了
  61.                             if (tabAt(tab, i) == f) {
  63.                                 //用于移动哈希桶元素到新的低地址元素
  64.                                 Node<K,V> ln;
  65.                                 //用于移动哈希桶元素到新的高地址元素 
  66.                                 Node<K,V> hn;
  67.                                 //如果哈希值大于0证明哈希桶是链表结构
  68.                                 if (fh >= 0) {
  70.                                     //n表示旧的哈希表长度且为2的n次方(方便利用位运算得到哈希位置)
  71.                                     //所以n的字节特点就是 只有一个1其余都是0.比如16二进制为1 0000
  72.                                     //因此跟n做位运算的与预算 结果只能为 0或者为n。
  73.                                     //如果fh & n 为n:
  74.                                     //证明此元素在新哈希表中的 x+n 位置上。（x为当前哈希表数组下标所在位置）
  75.                                     //对应下面代码  setTabAt(nextTab, i + n, hn);
  76.                                     //如果 fh & n 为0 ：
  77.                                     //那么此元素在新的哈希表中的位置和当前在旧的哈希表位置下标是一样,
  78.                                     //对应下面代码  setTabAt(nextTab, i, ln);
  79.                                     //上述数理逻辑读者可自行思考。
  80.                                     //逻辑不是太难理解，因为如果元素哈希值能于旧哈希表长度N按位与得到N,那么证明此元素在新哈希表长度M（为旧数组两倍M=2N）的下标必然大于n且为当前数组位置+n。
  81.                                     //比如 旧哈希表长度 等于8 新数组长度为16，某个元素的哈希值为15
  82.                                     //在旧的哈希表中：元素哈希对应数组下标为7。在新的数组中下标为15（旧数组下标+旧数组长度=7+8）.
  83.                                     int runBit = fh & n;
  84.                                     //当前指向哈希桶头结点
  85.                                     //在后面紧跟的for循环中改变指向为最后一个runBit不同的节点
  86.                                     Node<K,V> lastRun = f;
  88.                                     //这里目的是不知道怎么用言语去表述
  89.                                     //寻找到一个全部后续节点哈希值和旧数组长度相同哈希结果相同的第一个节点
  90.                                     //比如某个lastRun的p.hash & n为0，那么后续所有子元素都要求p.hash & n为0
  91.                                     //或者说某个lastRun的p.hash & n为n，那么后续所有子元素都要求p.hash & n为n
  92.                                     //这里这么做是方便移动哈希桶元素的到新哈希表的两种情况。（一种是保持位在新的哈希表不变，另一种是当前位置加旧哈希表长度）
  93.                                     for (Node<K,V> p = f.next; p != null; p = p.next) {
  95.                                         int b = p.hash & n;
  96.                                         if (b != runBit) {
  98.                                             runBit = b;
  99.                                             lastRun = p;
  100.                                         }
  101.                                     }
  102.                                     //判断lastRun是那种类型
  103.                                     if (runBit == 0) {
  105.                                         ln = lastRun;
  106.                                         hn = null;
  107.                                     }
  108.                                     else {
  110.                                         hn = lastRun;
  111.                                         ln = null;
  112.                                     }
  113.                                     //移动哈希桶所有元素到新哈希表。
  114.                                     //一种是下标不变移动
  115.                                     //另一种是 当前下标在旧哈希长度
  116.                                     for (Node<K,V> p = f; p != lastRun; p = p.next) {
  118.                                         int ph = p.hash; K pk = p.key; V pv = p.val;
  119.                                         if ((ph & n) == 0)
  120.                                             ln = new Node<K,V>(ph, pk, pv, ln);
  121.                                         else
  122.                                             hn = new Node<K,V>(ph, pk, pv, hn);
  123.                                     }
  124.                                     setTabAt(nextTab, i, ln);
  125.                                     setTabAt(nextTab, i + n, hn);
  126.                                     setTabAt(tab, i, fwd);
  127.                                     //设置advance为true让当前线程继续计算处理其他旧哈希桶位置的拷贝
  128.                                     advance = true;
  129.                                 }
  130.                                 else if (f instanceof TreeBin) {
  132.                                   //..红黑树部分略
  133.                                 }
  134.                             }
  135.                         }
  136.                     }
  137.                 }
  138. }

任何哈希桶下插入删除的操作需要加锁说明：

情况一：
多个线程想同时插入新的节点到同一个哈希桶的链表中。
在这里插入图片描述
情况二：

一个线程插入哈希桶，另一个线程进行移除操作。
在这里插入图片描述
虽然上述操作可以使用CAS加自旋完成，但是会增加复杂度。

参考文献

  1. 并发编程——ConcurrentHashMap#transfer() 扩容逐行分析
  2. 并发容器之ConcurrentHashMap详解(JDK1.8版本)与源码分析
  3. HashMap位运算你可知一二

发表评论

表情：
评论列表 （有 0 条评论，245人围观）

还没有评论，来说两句吧...

相关阅读

    相关 ConcurrentHashMap原理分析

    一.Java并发基础 当一个对象或变量可以被多个线程共享的时候，就有可能使得程序的逻辑出现问题。 在一个对象中有一个变量i=0，有两个线程A，B都想对i加1，这个时候便有

    梦里梦外;梦里梦外;/ 0 赞/ 332 阅读