• Map学习笔记——深入理解ConcurrentHashMap

    ConcurrentHashMap 是我们日常开发中使用频率最高的并发容器之一了，具有如下特点:

    基于JDK8分析

    1. 存储结构和HashMap一样，都是数组 + 链表 + 红黑树
    2. 是线程安全的容器，底层是通过CAS自旋 + sychronized 来保证的
    3. key 和 value 都不允许为空，否则将抛出空指针异常
    4. 对比HashTalbe,锁的粒度控制在数组的桶元素上
    5. 可以多线程协助扩容

    接下来从源码的角度来分析下 ConcurrentHashMap。

    1. 关键属性

    1. public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    2.     implements ConcurrentMap<K,V>, Serializable {
    3.     private static final long serialVersionUID = 7249069246763182397L;
    4.    
    5.     /**
    6.      * 数组的最大长度 （和HashMap一样)
    7.      */
    8.     private static final int MAXIMUM_CAPACITY = 1 << 30;
    9.  
    10.     /**
    11.      *  数组的默认长度 （和HashMap一样)
    12.      */
    13.     private static final int DEFAULT_CAPACITY = 16;
    14.  
    15.     /**
    16.      * 数组中的元素个数最大值，超过这个阈值将抛出OOM
    17.      */
    18.     static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    19.  
    20.     /**
    21.      * The default concurrency level for this table. Unused but defined for
    22.      * compatibility with previous versions of this class.
    23.      *
    24.      * 翻译过来是默认的并发级别，但是并没有使用
    25.      */
    26.     private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
    27.  
    28.     /**
    29.      * 加载因子
    30.      */
    31.     private static final float LOAD_FACTOR = 0.75f;
    32.  
    33.     /**
    34.      * 当链表长度达到8，转成红黑树
    35.      */
    36.     static final int TREEIFY_THRESHOLD = 8;
    37.  
    38.     /**
    39.      * 当红黑树的长度小于6，转成链表
    40.      */
    41.     static final int UNTREEIFY_THRESHOLD = 6;
    42.  
    43.     /**
    44.      * 当链表长度大于8，但是数组table长度没有达到64，此时不会转成红黑树，而是扩容
    45.      */
    46.     static final int MIN_TREEIFY_CAPACITY = 64;
    47.  
    48.     /**
    49.      * 最小的迁移步长，当多线程并发扩容时，每个线程负责的迁移的最小桶的个数
    50.      */
    51.     private static final int MIN_TRANSFER_STRIDE = 16;
    52.  
    53.     /**
    54.      * The number of bits used for generation stamp in sizeCtl.
    55.      * Must be at least 6 for 32bit arrays.
    56.      */
    57.     private static int RESIZE_STAMP_BITS = 16;
    58.  
    59.     /**
    60.      * The maximum number of threads that can help resize.
    61.      * Must fit in 32 - RESIZE_STAMP_BITS bits.
    62.      * 表示并发扩容最大线程数
    63.      */
    64.     private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
    65.  
    66.     /**
    67.      * The bit shift for recording size stamp in sizeCtl.
    68.      * 和扩容相关，用来标识sizeCtl的符号位
    69.      */
    70.     private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
    71.  
    72.     /*
    73.      * Encodings for Node hash fields. See above for explanation.
    74.      */
    75.     //旧数组迁移后，桶位会放入ForwardingNode节点，hash值固定为-1
    76.     static final int MOVED     = -1; // hash for forwarding nodes
    77.     //红黑树在桶中元素的节点(TreeBin)的hash值固定为-2
    78.     static final int TREEBIN   = -2; // hash for roots of trees
    79.     static final int RESERVED  = -3; // hash for transient reservations
    80.     //保证hash值都是正数
    81.     static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
    82.  
    83.     /*
    84.      * 处理器的核数
    85.      */
    86.     static final int NCPU = Runtime.getRuntime().availableProcessors();
    87.  
    88.  
    89.     /**
    90.      * table
    91.      */
    92.     static class Node<K,V> implements Map.Entry<K,V> {
    93.         final int hash;
    94.         final K key;
    95.         volatile V val;            //value是volatile的
    96.         volatile Node<K,V> next;   //next是volatile的
    97.  
    98.         Node(int hash, K key, V val, Node<K,V> next) {
    99.             this.hash = hash;
    100.             this.key = key;
    101.             this.val = val;
    102.             this.next = next;
    103.         }
    104.  
    105.         //.......
    106.     }
    107.  
    108.  
    109.     /* ---------------- Fields -------------- */
    110.  
    111.     /**
    112.      * table数组，长度总是2的N次幂
    113.      */
    114.     transient volatile Node<K,V>[] table;
    115.  
    116.     /**
    117.      * 扩容时使用的
    118.      */
    119.     private transient volatile Node<K,V>[] nextTable;
    120.  
    121.     /**
    122.      * 记录元素个数的基准值
    123.      */
    124.     private transient volatile long baseCount;
    125.  
    126.     /**
    127.      * table数组初始化和扩容的控制符，不同值有不同的含义：
    128.      * 1.如果值为-1，则表示table数组正在初始化；-(n + 1) 表示表示此时有n个线程正在共同完成数组的扩容操作
    129.      * 2.如果值为0，表示table数组还没有被初始化，默认长度是16
    130.      * 3.值为正数，如果数组没有初始化，则记录的是数组的初始容量；如果数组已经初始化，记录的是数组的扩容阈值(capacity * loadFactor)
    131.      *
    132.      * 这个值是非常重要的
    133.      */
    134.     private transient volatile int sizeCtl;
    135.  
    136.     /**
    137.      * 迁移时的索引
    138.      */
    139.     private transient volatile int transferIndex;
    140.  
    141.     /**
    142.      * 自旋锁标志位
    143.      * 在在调整CounterCell[]大小和或创建CounterCell[]时使用。
    144.      */
    145.     private transient volatile int cellsBusy;
    146.  
    147.     /**
    148.      * 当put元素并进行计数时，优先对baseCount进行加1操作，但是并发度高的情况下，只有一个线程能
    149.      * 成功，其他失败的线程将会使用CounterCell进行统计。
    150.      * 这样元素的总个数 = baseCount + CounterCell[]数组各个下标对应值的总和
    151.      */
    152.     private transient volatile CounterCell[] counterCells;
    153.  
    154. }
    155. 复制代码

    sizeCtl 属性着重说明一下：

    1. 如果值为 -1，则表示table数组正在初始化；-(n + 1) 表示表示此时有多个线程正在共同完成数组的扩容操作
    2. 如果值为0，表示table数组还没有被初始化，默认长度是16
    3. 值为正数，如果数组没有初始化，则记录的是数组的初始容量；如果数组已经初始化(table != null)，记录的是数组的扩容阈值(capacity * loadFactor)

    2.构造器分析

    1. public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    2.     implements ConcurrentMap<K,V>, Serializable {
    3.     private static final long serialVersionUID = 7249069246763182397L;
    4.    
    5.     /**
    6.      * 如果使用的空参数构造器，那么默认的长度16
    7.      */
    8.     public ConcurrentHashMap() {
    9.     }
    10.  
    11.     /**
    12.      * 指定初始容量
    13.      * 如果初始容量大于(最大值/2 = 2^29),那么初始容量就是默认的最大值2^30
    14.      * 否则去初始容量的(1.5倍+1),然后计算出大于该值的最小的2的N次幂
    15.      *
    16.      *
    17.      * 同时，将初始容量赋给sizeCtl, 表示数组还没有初始化
    18.      */
    19.     public ConcurrentHashMap(int initialCapacity) {
    20.         if (initialCapacity < 0)
    21.             throw new IllegalArgumentException();
    22.         int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
    23.                    MAXIMUM_CAPACITY :
    24.                    tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    25.         this.sizeCtl = cap;
    26.     }
    27.  
    28.     //.....其他构造器......
    29.  
    30. }
    31. 复制代码

    tableSizeFor()方法并不陌生，前面讲HashMap的时候，我们有提到，不过二者在计算数组的初始容量稍有差异，HashMap直接对指定容量进行位运算，计算出大于等于指定容量的最小的2的N次幂；而ConcurrentHashMap是先对指定容量进行(1.5倍 + 1), 然后对计算后的值进行位运算，得到大于该值的最小的2的N次幂。

    HashMap: 7 ——> 8，17 ——> 32，16 ——> 16，1 ——> 1
    ConcurrentHashMap: 7 ——> 16，17 ——> 32，32 ——> 64，1 ——> 2

    3.put()方法分析

    测试数据：

    1. public class Test {
    2.  
    3.     public static void main(String[] args) {
    4.  
    5.         //此时初始容量是64，由于内部的table还没有初始化，所以sizeCtl属性值为初始容量64
    6.         ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(32);
    7.         map.put("abc", 12);
    8.        
    9.     }
    10. }    
    11. 复制代码

    源码分析：

    1. final V putVal(K key, V value, boolean onlyIfAbsent) {
    2.     //key和value 都不允许为空
    3.     if (key == null || value == null) throw new NullPointerException();
    4.     /**
    5.      * 通过扰动函数，计算出hash值，高16位也参与运算，这个和HashMap一样
    6.      * 不过计算出结果后，它会 &0x7fffffff，其目的是，这样计算出来的hash值都是正数!
    7.      */
    8.     int hash = spread(key.hashCode());
    9.     int binCount = 0;
    10.     //死循环，搭配CAS做自旋用的
    11.     for (Node<K,V>[] tab = table;;) {
    12.         Node<K,V> f; int n, i, fh;
    13.         //如果数组是空的，则需要初始化table数组 ①
    14.         if (tab == null || (n = tab.length) == 0)
    15.             tab = initTable();
    16.         //数组不为空，计算当前key在数组中桶的下标，如果为空，则表示没有放元素，则通过cas设置元素    
    17.         else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
    18.             if (casTabAt(tab, i, null,
    19.                          new Node<K,V>(hash, key, value, null)))
    20.                 break;                   //设置成功，break
    21.         }
    22.         //如果桶中元素的hash值为-1，表示当前数组正在扩容
    23.         else if ((fh = f.hash) == MOVED)
    24.             //当前线程协助扩容
    25.             tab = helpTransfer(tab, f);
    26.         else {  //否则就需要插入到链表或者红黑树中
    27.             V oldVal = null;
    28.             //对数组中的桶节点元素加锁
    29.             synchronized (f) {
    30.                 //double check, 避免其他线程将树转成了红黑树，或者其他线程移除了该元素
    31.                 if (tabAt(tab, i) == f) {
    32.                     /**
    33.                      * fh >= 0, 表示普通的链表节点
    34.                      * 能走到这里，说明数组中的桶元素不为空，同时hash值也不是-1
    35.                      * 同时，如果是红黑树，则桶中元素放到的是TreeBin节点，它的hash值固定是-2，
    36.                      * 所以，如果 fh>=0,则是普通链表
    37.                      */
    38.                     if (fh >= 0) {
    39.                         binCount = 1;
    40.                         //整个for循环是处理链表
    41.                         for (Node<K,V> e = f;; ++binCount) {
    42.                             K ek;
    43.                             if (e.hash == hash &&
    44.                                 ((ek = e.key) == key ||
    45.                                  (ek != null && key.equals(ek)))) {
    46.                                 oldVal = e.val;
    47.                                 if (!onlyIfAbsent)
    48.                                     e.val = value;
    49.                                 break;
    50.                             }
    51.                             Node<K,V> pred = e;
    52.                             if ((e = e.next) == null) {
    53.                                 pred.next = new Node<K,V>(hash, key,
    54.                                                           value, null);
    55.                                 break;
    56.                             }
    57.                         }
    58.                     }
    59.                     //红黑树
    60.                     else if (f instanceof TreeBin) {
    61.                         Node<K,V> p;
    62.                         binCount = 2;
    63.                         //插入到红黑树中
    64.                         if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
    65.                                                        value)) != null) {
    66.                             oldVal = p.val;
    67.                             if (!onlyIfAbsent)
    68.                                 p.val = value;
    69.                         }
    70.                     }
    71.                 }
    72.             }
    73.             if (binCount != 0) {
    74.                 //如果链表长度大于等于8，则将链表转成红黑树
    75.                 if (binCount >= TREEIFY_THRESHOLD)
    76.                     treeifyBin(tab, i);
    77.                 if (oldVal != null)
    78.                     return oldVal;
    79.                 break;
    80.             }
    81.         }
    82.     }
    83.     //元素个数+1
    84.     addCount(1L, binCount);
    85.     return null;
    86. }
    87. 复制代码

    接下来我们研究一下功能点的细节方法

    3.1 表的初始化——initTable()

    1. private final Node<K,V>[] initTable() {
    2.     Node<K,V>[] tab; int sc;
    3.     //while循环+CAS形成自旋
    4.     while ((tab = table) == null || tab.length == 0) {
    5.         /*
    6.          * 1.如果值为-1，则表示table数组正在初始化；-(n + 1) 表示表示此时有n个线程正在共同完成数组的扩容操作
    7.          * 2.如果值为0，表示table数组还没有被初始化，默认长度是16
    8.          * 3.值为正数，如果数组没有初始化，则记录的是数组的初始容量；如果数组已经初始化，记录的是数组的扩容阈值(capacity * loadFactor)
    9.          *
    10.          */
    11.         //如果值小于0，说明正在初始化或者扩容，此时当前的线程就直接放弃CPU的使用权
    12.         //由运行状态变为就绪状态，再次获得CPU的控制权后接着往下执行，这里也就是继续执行while循环
    13.         if ((sc = sizeCtl) < 0)
    14.             Thread.yield(); // lost initialization race; just spin
    15.         /**
    16.          * 在测试数据中，我们指定了初始容量，在没有初始化的情况下，sizeCtl等于初始容量也就是64 > 0
    17.          * 利用CAS将sizeCtl修改为-1
    18.          *
    19.          * U.compareAndSwapInt(this, SIZECTL, sc, -1) 
    20.          * 如果SIZECTL(就是sizeCtl在内存中的偏移量)和sc相等，则将SIZECTL(就是sizeCtl)修改为-1
    21.          */
    22.         else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
    23.             try {
    24.                 /*
    25.                  * 为什么要double check ?
    26.                  * 因为finally 中 sizeCtl = sc; 此时 sizeCtl是扩容阈值，其他线程
    27.                  * 来到else if 判断为true, 则也可以进来，这样就重复初始化了
    28.                  */
    29.                 if ((tab = table) == null || tab.length == 0) {
    30.                     //这里的sc还是初始容量，请看指定容量的构造器方法
    31.                     int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
    32.                     @SuppressWarnings("unchecked")
    33.                     Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
    34.                     table = tab = nt;
    35.                     /**
    36.                      * 重新计算sc: 因为table已经初始化了，所以这sc值在这里就是扩容阈值了
    37.                      *
    38.                      *  n - (n >>> 2) = n - n/4 = 3/4(n) = 0.75 * n
    39.                      *  sc = 0.75 * table.length
    40.                      */
    41.                     sc = n - (n >>> 2);
    42.                 }
    43.             } finally {
    44.                 sizeCtl = sc;
    45.             }
    46.             break;
    47.         }
    48.     }
    49.     return tab;
    50. }
    51. 复制代码

    初始化完成之后，就不走其他判断了，直接重新循环，此时table已经不为空了，然后根据key计算在数组中的索引，判断是否为空，如果为空，则通过CAS插入元素。

    3.2 CAS插入元素

    这里比较简单，如果数组中该索引位置没有元素，则直接通过CAS插入即可；如果插入失败，则说明有其他线程先一步插入了该位置，则CAS失败，此时就重新for循环然后插入到链表位置。

    接下来我们先看下如果出现hash冲突如何解决，协助扩容晚点再探究。

    3.3 hash冲突

    1. final V putVal(K key, V value, boolean onlyIfAbsent) {
    2.     //key和value 都不允许为空
    3.     if (key == null || value == null) throw new NullPointerException();
    4.     /**
    5.      * 通过扰动函数，计算出hash值，高16位也参与运算，这个和HashMap一样
    6.      * 不过计算出结果后，它会 &0x7fffffff，其目的是，这样计算出来的hash值都是正数!
    7.      */
    8.     int hash = spread(key.hashCode());
    9.     int binCount = 0;
    10.     //死循环，搭配CAS做自旋用的
    11.     for (Node<K,V>[] tab = table;;) {
    12.         Node<K,V> f; int n, i, fh;
    13.         
    14.         //....省略其他else if........
    15.         
    16.         //hash碰撞的处理逻辑
    17.         else {
    18.             V oldVal = null;
    19.             //对数组中的桶节点元素加锁
    20.             synchronized (f) {
    21.                 //double check, 避免其他线程将树转成了红黑树，或者其他线程移除了该元素
    22.                 if (tabAt(tab, i) == f) {
    23.                     /**
    24.                      * fh >= 0, 表示普通的链表节点
    25.                      * 能走到这里，说明数组中的桶元素不为空，同时hash值也不是-1
    26.                      * 同时，如果是红黑树，则桶中元素放到的是TreeBin节点，它的hash值固定是-2，
    27.                      * 所以，如果 fh>=0,则是普通链表
    28.                      */
    29.                     if (fh >= 0) {
    30.                         binCount = 1;
    31.                         //处理链表
    32.                         for (Node<K,V> e = f;; ++binCount) {
    33.                             K ek;
    34.                             if (e.hash == hash &&
    35.                                 ((ek = e.key) == key ||
    36.                                  (ek != null && key.equals(ek)))) {
    37.                                 oldVal = e.val;
    38.                                 if (!onlyIfAbsent)
    39.                                     e.val = value;
    40.                                 break;
    41.                             }
    42.                             Node<K,V> pred = e;
    43.                             if ((e = e.next) == null) {
    44.                                 pred.next = new Node<K,V>(hash, key,
    45.                                                           value, null);
    46.                                 break;
    47.                             }
    48.                         }
    49.                     }
    50.                     //红黑树
    51.                     else if (f instanceof TreeBin) {
    52.                         Node<K,V> p;
    53.                         binCount = 2;
    54.                         //插入到红黑树中
    55.                         if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
    56.                                                        value)) != null) {
    57.                             oldVal = p.val;
    58.                             if (!onlyIfAbsent)
    59.                                 p.val = value;
    60.                         }
    61.                     }
    62.                 }
    63.             }
    64.             if (binCount != 0) {
    65.                 //如果链表长度大于等于8，则将链表转成红黑树
    66.                 if (binCount >= TREEIFY_THRESHOLD)
    67.                     treeifyBin(tab, i);
    68.                 if (oldVal != null)
    69.                     return oldVal;
    70.                 break;
    71.             }
    72.         }
    73.     }
    74.     //元素个数+1
    75.     addCount(1L, binCount);
    76.     return null;
    77. }
    78. 复制代码

    不难发现，如果出现hash冲突，则锁住当前桶位，对比HashTable, 锁的粒度直接从锁整个表下降到锁表中的某一个桶位，并发度将大大提高。如果是链表，则采用尾插法插入到链表尾部；如果是红黑树，则将元素插入到红黑树中；如果链表长度 >=8，则将链表转成红黑树。接下来我们简单看下链表转成红黑树的逻辑：

    1. private final void treeifyBin(Node<K,V>[] tab, int index) {
    2.     Node<K,V> b; int n, sc;
    3.     if (tab != null) {
    4.         /**
    5.          * 链表长度大于8，但是数组长度没有达到64，此时不会转成红黑树，而是先扩容
    6.          * 这一点和HashMap一样
    7.          */
    8.         if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
    9.             tryPresize(n << 1); //扩容2倍，扩容的逻辑放到后面再说
    10.         /**
    11.          * 1.找到桶中的元素，并且不为空
    12.          * 2.hash值要大于0，为什么?
    13.          *   因为桶中元素的hash值小于0，只有两种情况
    14.          *   1)数组正在扩容，旧数组迁移后的桶的位置会放一个 ForwardingNode 节点，它的hash值是-1
    15.          *   2)桶中的元素已经是树了，此时桶中元素的hash值是-2
    16.          */
    17.         else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
    18.             //锁住当前桶中的元素，开始树化
    19.             synchronized (b) {
    20.                 /**
    21.                  * double check
    22.                  * 为什么要double check ?
    23.                  * 因为有可能当前线程进来了else if, 但是还没有执行sychronized获得锁之前，有其他线程
    24.                  * 已经获得了这个锁，然后开始树化，树化后节点元素可能随着左旋和右旋而改变，所以这里必须要double check
    25.                  */
    26.                 if (tabAt(tab, index) == b) {
    27.                     //整个for循环就做一件事，将当前的单向链表转成双向链表
    28.                     //hd 是双向链表的头节点
    29.                     TreeNode<K,V> hd = null, tl = null;
    30.                     for (Node<K,V> e = b; e != null; e = e.next) {
    31.                         TreeNode<K,V> p =
    32.                             new TreeNode<K,V>(e.hash, e.key, e.val,
    33.                                               null, null);
    34.                         if ((p.prev = tl) == null)
    35.                             hd = p;
    36.                         else
    37.                             tl.next = p;
    38.                         tl = p;
    39.                     }
    40.                     
    41.                     /**
    42.                      * 将当前桶的位置设置为 TreeBin 节点，然后将双向链表通过构造器传入到
    43.                      * 内部，然后再内部将双向链表转成红黑树。
    44.                      * 注意：桶中的TreeBin 的hash值是 -2
    45.                      */
    46.                     setTabAt(tab, index, new TreeBin<K,V>(hd));
    47.                 }
    48.             }
    49.         }
    50.     }
    51. }
    52. 复制代码

    我们用一张图来展示下红黑树的存储结构：

    3.4 统计元素个数

    我们看下addCount()方法的内部实现：

    这个方法内部主要做两件事：一个是统计元素个数，另一个是扩容

    1. private final void addCount(long x, int check) {
    2.     CounterCell[] as; long b, s;
    3.     /**
    4.      * 1.统计元素个数
    5.      * 优先对baseCount进行加，但是高并发下，只能有一个线程通过CAS添加成功，其他的线程CAS会失败
    6.      * 此时那些失败的线程就会跳过对baseCount的运算，而是去对CounterCell[]数组中的元素进行计数
    7.      * 这样总的元素个数 = baseCount + CounterCell[]数组各个元素的和
    8.      */
    9.     if ((as = counterCells) != null ||
    10.         !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
    11.         CounterCell a; long v; int m;
    12.         boolean uncontended = true;
    13.         if (as == null || (m = as.length - 1) < 0 ||
    14.             (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
    15.             !(uncontended =
    16.               U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
    17.             fullAddCount(x, uncontended);
    18.             return;
    19.         }
    20.         if (check <= 1)
    21.             return;
    22.         s = sumCount();
    23.     }
    24.     
    25.     /**
    26.      * 如果check >= 0, 则需要判断是否扩容，因为remove()的话，也会调用调用这个方法
    27.      * 传入的是 -1，此时是不需要扩容的。
    28.      *
    29.      */
    30.     if (check >= 0) {
    31.         Node<K,V>[] tab, nt; int n, sc;
    32.         while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
    33.                (n = tab.length) < MAXIMUM_CAPACITY) {
    34.             int rs = resizeStamp(n);
    35.             if (sc < 0) {
    36.                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
    37.                     sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
    38.                     transferIndex <= 0)
    39.                     break;
    40.                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
    41.                     transfer(tab, nt);
    42.             }
    43.             else if (U.compareAndSwapInt(this, SIZECTL, sc,
    44.                                          (rs << RESIZE_STAMP_SHIFT) + 2))
    45.                 transfer(tab, null);
    46.             s = sumCount();
    47.         }
    48.     }
    49. }
    50. 复制代码

    我们先用一张图来整体概括下计数的逻辑：

    我们来详细分析下统计元素个数的逻辑：

    参考JUC下的原子类 LongAdder，他们的逻辑是一模一样的。使用了分段CAS的思想

    1. /**
    2.  * 1.统计元素个数
    3.  * 优先对baseCount进行加，但是高并发下，只能有一个线程通过CAS添加成功，其他的线程CAS会失败
    4.  * 此时那些失败的线程就会跳过对baseCount的运算，而是去对CounterCell[]数组中的元素进行计数
    5.  * 这样总的元素个数 = baseCount + CounterCell[]数组各个元素的和
    6.  */
    7. private final void addCount(long x, int check) {
    8.     CounterCell[] as; long b, s;
    9.     /**
    10.      * 不难发现，一旦并发比较高，对baseCount加失败后，就会对counterCells计数，之后就都会
    11.      * 对 counterCells 计数，不在对baseCount计数了。
    12.      *
    13.      * 一旦CAS对baseCount计数成功，就退出了
    14.      * 一旦CAS对baseCount计数失败，取反就是true,开始初始化counterCells然后计数
    15.      * 
    16.      */
    17.     if ((as = counterCells) != null ||
    18.         !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
    19.         CounterCell a; long v; int m;
    20.         boolean uncontended = true;
    21.         if (as == null || (m = as.length - 1) < 0 ||
    22.             (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
    23.             !(uncontended =
    24.               U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
    25.             //对counterCells计数的核心逻辑  
    26.             fullAddCount(x, uncontended);
    27.             return;
    28.         }
    29.         if (check <= 1)
    30.             return;
    31.         s = sumCount();
    32.     }
    33.     
    34.     //......先省略扩容的逻辑........
    35. }    
    36. 复制代码

    接下来我们看下对 counterCells 计数的逻辑：

    核心逻辑主要就是集中在这3个判断中:

    1. 第一个判断主要是对 counterCells 数组进行扩容，每次也是以2的N次幂进行扩容，初始容量是2
    2. 第二个判断主要是初始化 counterCells 数组
    3. 第三个判断是如果对counterCells计数失败了，回过头来在对baseCount计数，吃回头草。

    接下来我们在详细展开看看：

    1. private final void fullAddCount(long x, boolean wasUncontended) {
    2.     int h;
    3.     /**
    4.      * h: 可以理解为一个随机数，用来计数counterCells数组索引位置的
    5.      * h = ThreadLocalRandom.getProbe()) == 0 说明还没有初始化，调用localInit()初始化，产生一个随机数
    6.      */
    7.     if ((h = ThreadLocalRandom.getProbe()) == 0) {
    8.         ThreadLocalRandom.localInit();      // force initialization
    9.         h = ThreadLocalRandom.getProbe();
    10.         wasUncontended = true;
    11.     }
    12.     //碰撞的意思
    13.     boolean collide = false;                // True if last slot nonempty（如果最后一个槽位非空则为True）
    14.     for (;;) {
    15.         CounterCell[] as; CounterCell a; int n; long v;
    16.         /**
    17.          * 1.这里已经完成了对counterCells的初始化操作。我们先看步骤2判断
    18.          *
    19.          */
    20.         if ((as = counterCells) != null && (n = as.length) > 0) {
    21.             /**
    22.              * 1.1计算counterCells数组中元素的位置是否为空
    23.              *
    24.              * 无论h是什么，假如n就是初始容量2，h&1位运算结果只能是0或1（因为h只有最后一个位参与运算)
    25.              * (a = as[(n - 1) & h]) == null 说明counterCells数组的位置没有值
    26.              *
    27.              */
    28.             if ((a = as[(n - 1) & h]) == null) {
    29.                 //cellsBusy == 0 说明counterCells没有初始化也没有扩容
    30.                 if (cellsBusy == 0) { 
    31.                     //创建一个  CounterCell 对象，将保存到 counterCells数组中
    32.                     CounterCell r = new CounterCell(x); // Optimistic create
    33.                     /**
    34.                      * 这里为什么还要对cellsBusy CAS 判断呢？
    35.                      * 说白了，来到这里也有可能是多个线程，所以必须确保只能有一个操作成功
    36.                      */
    37.                     if (cellsBusy == 0 &&
    38.                         U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
    39.                         boolean created = false;
    40.                         try {               
    41.                             //依然double check, 因为有可能执行完finally逻辑后，另一个线程就进来了
    42.                             CounterCell[] rs; int m, j;
    43.                             if ((rs = counterCells) != null &&
    44.                                 (m = rs.length) > 0 &&
    45.                                 rs[j = (m - 1) & h] == null) {
    46.                                 rs[j] = r;
    47.                                 created = true;
    48.                             }
    49.                         } finally {
    50.                             cellsBusy = 0;
    51.                         }
    52.                         if (created)
    53.                             break;
    54.                         continue;           // Slot is now non-empty
    55.                     }
    56.                 }
    57.                 collide = false;
    58.             }
    59.             //Uncontended 是无竞争的意思
    60.             else if (!wasUncontended)       // CAS already known to fail
    61.                 wasUncontended = true;      // Continue after rehash
    62.             /**
    63.              * 尝试用CAS对该单元格的值累加，如果成功则退出
    64.              */
    65.             else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
    66.                 break;
    67.             else if (counterCells != as || n >= NCPU)
    68.                 collide = false;            // At max size or stale
    69.             else if (!collide)
    70.                 collide = true;
    71.             /**
    72.              * 多次尝试操作后，依然失败了，说明对couterCells并发非常高，则此时尝试扩容
    73.              * 扩容为原来的2倍（也是2的N次幂）
    74.              */
    75.             else if (cellsBusy == 0 &&
    76.                      U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
    77.                 try {
    78.                     if (counterCells == as) {// Expand table unless stale
    79.                         CounterCell[] rs = new CounterCell[n << 1];
    80.                         for (int i = 0; i < n; ++i)
    81.                             rs[i] = as[i];
    82.                         counterCells = rs;
    83.                     }
    84.                 } finally {
    85.                     cellsBusy = 0;
    86.                 }
    87.                 collide = false;
    88.                 continue;                   // Retry with expanded table
    89.             }
    90.             //产生一个新的随机数
    91.             h = ThreadLocalRandom.advanceProbe(h);
    92.         }
    93.         /**
    94.          * 2.初始化counterCells数组，先看这里。
    95.          * cellsBusy == 0 表示不忙，也就是还没有初始化，然后通过CAS将其修改为1，表示忙
    96.          * 在搭配double check 这样其他线程就无法再进来重复初始化了
    97.          *
    98.          */
    99.         else if (cellsBusy == 0 && counterCells == as &&
    100.                  U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
    101.             boolean init = false;
    102.             try {  
    103.                 // double check
    104.                 if (counterCells == as) {
    105.                     //创建一个长度为2的数组
    106.                     CounterCell[] rs = new CounterCell[2];
    107.                     /**
    108.                      * 计算索引位置，h是一个随机数
    109.                      * h & 1 的结果要么是0，要么是1，因为无论h是什么，它只有最后1位参与位运算
    110.                      * 索引，这个x值可能放在index = 0的位置，或者放到index = 1的位置
    111.                      */
    112.                     rs[h & 1] = new CounterCell(x);
    113.                     //赋值，完成初始化操作
    114.                     counterCells = rs;
    115.                     init = true;
    116.                 }
    117.             } finally {
    118.                 cellsBusy = 0;
    119.             }
    120.             if (init)
    121.                 break;
    122.         }
    123.         //如果对counterCells计数失败，回过头来在对baseCount计数
    124.         else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
    125.             break;                          // Fall back on using base
    126.     }
    127. }
    128. 复制代码

    整个流程我们用下面这个图概括下：

    如何计算元素个数呢？

    1. final long sumCount() {
    2.     CounterCell[] as = counterCells; CounterCell a;
    3.     //先取出baseCount的值
    4.     long sum = baseCount; 
    5.     //再取出counterCells数组中每个单元格的值
    6.     if (as != null) {
    7.         for (int i = 0; i < as.length; ++i) {
    8.             if ((a = as[i]) != null)
    9.                 sum += a.value;
    10.         }
    11.     }
    12.     return sum;
    13. }
    14. 复制代码

    好了，关于统计元素个数就梳理到这里，接下来我们看下是否扩容的逻辑。

    3.5 扩容

    1. private final void addCount(long x, int check) {
    2.     
    3.     //......省略统计元素个数的逻辑........
    4.     
    5.     //如果是remove元素，则不要走扩容逻辑了,remove传过来的是-1
    6.     if (check >= 0) {
    7.         Node<K,V>[] tab, nt; int n, sc;
    8.         /**
    9.          * s = sumCount() 就是元素个数
    10.          * 因为table已经完成了初始化(table != null),所以sizeCtl此时表示扩容阈值
    11.          * s >= (long)(sc = sizeCtl): 判断集合元素个数是否大于扩容阈值，超过则扩容
    12.          */
    13.         while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
    14.                (n = tab.length) < MAXIMUM_CAPACITY) {
    15.             /**
    16.              * 内部实现：Integer.numberOfLeadingZeros(n) | (1 << (16 - 1));
    17.              * 先不看前面，二者按位或之后第17位肯定是1，其他先不管
    18.              */
    19.             int rs = resizeStamp(n);
    20.             /**
    21.              * sc < 0 是什么情况？很明显就是扩容了
    22.              * 
    23.              * 假设a,b两个线程同时来到while这里，a线程优先执行了else if, 此时将会把
    24.              * sizeCtl修改为负数，此时b线程判断 sc < 0 就成立了。
    25.              *
    26.              * 假如a线程执行完CAS判断后，还没有执行transfer(tab, null)方法，此时切换
    27.              * 到b线程，由于nextTable == null, 所以b线程直接退出了。这怎么理解 ？
    28.              *  1）b线程已经将元素添加到old table中了
    29.              *  2）元素个数已经统计完毕了
    30.              * 所以，直接让b线程退出，由a线程完成迁移工作就可以了。。。。。
    31.              *
    32.              * 假如a线程执行完CAS判断后，开始执行transfer(tab, null)方法，nextTable != null
    33.              * 此时切换到b线程，b线程执行CAS判断后，执行transfer(tab, nt) 方法，这里怎么理解？
    34.              * --这里就是协助扩容了。
    35.              *  
    36.              *
    37.              */
    38.             if (sc < 0) {
    39.                 /**
    40.                  * 判断是否已经扩容结束了，nextTable就是扩容后的新数组
    41.                  * 扩容完成后，会将nextTable 赋给 table
    42.                  */
    43.                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
    44.                     sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
    45.                     transferIndex <= 0)
    46.                     break;
    47.                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
    48.                     //协助扩容
    49.                     transfer(tab, nt);
    50.             }
    51.             /*
    52.              * 将rs左移16位，使sizeCtl变成负数
    53.              */
    54.             else if (U.compareAndSwapInt(this, SIZECTL, sc,
    55.                                          (rs << RESIZE_STAMP_SHIFT) + 2))
    56.                 //当前线程是触发扩容的第一个线程                     
    57.                 transfer(tab, null);
    58.             s = sumCount();
    59.         }
    60.     }
    61. }
    62. 复制代码

    我们先来看下rs变量的含义：

    1. static final int resizeStamp(int n) {
    2.     //RESIZE_STAMP_BITS = 16
    3.     return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
    4. }
    5. 复制代码

    首先将1左移15位：

    1. 00000000 00000000 00000000 00000001
    2. 00000000 00000000 10000000 00000000 #左移15位，前面15位去掉，后面补15位
    3. 复制代码

    不管 Integer.numberOfLeadingZeros(n)的值是什么，他们按位或的结果，其中第17位一定是1.

    我们继续看 else if 中的CAS的逻辑：

    1. //RESIZE_STAMP_SHIFT = 16
    2. else if (U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2))
    3. 复制代码

    其中要对rs的值左移16位:

    1. 00000000 00000000 10000000 00000000  #rs
    2. 10000000 11100111 00111111 11111000  # rs << 16
    3. 复制代码

    rs 左移16位，会将第17位的1移动到首位，这意味着什么？意味着rs 是一个小于0的数值。只看首尾就好，其他位是什么不重要。

    接下来我们就看下扩容的核心逻辑(非常复杂):

    1. private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    2.     int n = tab.length, stride;
    3.     /**
    4.      * 这个方法是可以完成多个线程的共同扩容的
    5.      * 这里的含义就是对旧数组分块，每个线程负责多少块(步长)的数据迁移。
    6.      * 默认是每个线程负责16个桶位的迁移
    7.      * 当然了，如果是单核，那就完全没有必要使用多线程扩容了，数组长度是多少，线程就负责多少个元素(步长)
    8.      */
    9.     if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
    10.         stride = MIN_TRANSFER_STRIDE; // subdivide range
    11.     if (nextTab == null) {            // initiating
    12.         try {
    13.             //创建新的数组，长度为原来的2倍
    14.             Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
    15.             nextTab = nt;
    16.         } catch (Throwable ex) {      // try to cope with OOME
    17.             sizeCtl = Integer.MAX_VALUE;
    18.             return;
    19.         }
    20.         //方便协助扩容的线程拿到新表
    21.         nextTable = nextTab;
    22.         //transferIndex 就是旧数组的长度
    23.         transferIndex = n;
    24.     }
    25.     int nextn = nextTab.length;
    26.     /**
    27.      * 创建一个 fwd 节点，它的hash值固定为 -1
    28.      */
    29.     ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    30.     //迁移推进标识
    31.     boolean advance = true;
    32.     boolean finishing = false; // to ensure sweep before committing nextTab
    33.     for (int i = 0, bound = 0;;) {
    34.         Node<K,V> f; int fh;
    35.         /**
    36.          * 这个while的逻辑：
    37.          *  1）给每个线程分配迁移的任务(默认16个长度)
    38.          *  2) 从后往前一个一个迁移
    39.          */
    40.         while (advance) {
    41.             int nextIndex, nextBound;
    42.             /**
    43.              * boud 是一个任务段的边界值，请看下面的图
    44.              * 没有达到边界值之前，一个一个元素的迁移
    45.              */
    46.             if (--i >= bound || finishing)
    47.                 advance = false;
    48.             //迁移到最后一个元素了    
    49.             else if ((nextIndex = transferIndex) <= 0) {
    50.                 i = -1;
    51.                 advance = false;
    52.             }
    53.             /**
    54.              * 这里的逻辑就是为每个线程分配一个任务段(默认就是16个桶位的长度)
    55.              *
    56.              */
    57.             else if (U.compareAndSwapInt
    58.                      (this, TRANSFERINDEX, nextIndex,
    59.                       nextBound = (nextIndex > stride ?
    60.                                    nextIndex - stride : 0))) {
    61.                 bound = nextBound;
    62.                 i = nextIndex - 1;
    63.                 advance = false;
    64.             }
    65.         }
    66.         /**
    67.          * 这个if的判断就是：检查是否所有线程都迁移完成
    68.          *
    69.          *
    70.          */
    71.         if (i < 0 || i >= n || i + n >= nextn) {
    72.             int sc;
    73.             if (finishing) {
    74.                 nextTable = null;
    75.                 table = nextTab;
    76.                 sizeCtl = (n << 1) - (n >>> 1);
    77.                 return;
    78.             }
    79.             if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
    80.                 /**
    81.                  * 所有线程都迁移完成
    82.                  */
    83.                 if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
    84.                     return;
    85.                 finishing = advance = true;
    86.                 /**
    87.                  * 再次review旧数组每个节点，确保没有遗漏的
    88.                  * 来到这里，i = oldTable.legnth, bound = 0
    89.                  */
    90.                 i = n; // recheck before commit
    91.             }
    92.         }
    93.         //从这接下来的判断就是真正的迁移了
    94.         //如果旧数组位置是null,那干脆不用迁移了，直接放一个fwd节点，告诉其他线程正在扩容，
    95.         //不要再往旧数组放了，你可以过来协助扩容
    96.         else if ((f = tabAt(tab, i)) == null)
    97.             advance = casTabAt(tab, i, null, fwd);
    98.         //说明已经迁移过了    
    99.         else if ((fh = f.hash) == MOVED)
    100.             advance = true; // already processed
    101.         //迁移真正有数据的桶位    
    102.         else {
    103.             synchronized (f) {
    104.                 if (tabAt(tab, i) == f) {
    105.                     Node<K,V> ln, hn;
    106.                     //处理链表
    107.                     if (fh >= 0) {
    108.                         int runBit = fh & n;
    109.                         Node<K,V> lastRun = f;
    110.                         for (Node<K,V> p = f.next; p != null; p = p.next) {
    111.                             int b = p.hash & n;
    112.                             if (b != runBit) {
    113.                                 runBit = b;
    114.                                 lastRun = p;
    115.                             }
    116.                         }
    117.                         if (runBit == 0) {
    118.                             ln = lastRun;
    119.                             hn = null;
    120.                         }
    121.                         else {
    122.                             hn = lastRun;
    123.                             ln = null;
    124.                         }
    125.                         for (Node<K,V> p = f; p != lastRun; p = p.next) {
    126.                             int ph = p.hash; K pk = p.key; V pv = p.val;
    127.                             if ((ph & n) == 0)
    128.                                 ln = new Node<K,V>(ph, pk, pv, ln);
    129.                             else
    130.                                 hn = new Node<K,V>(ph, pk, pv, hn);
    131.                         }
    132.                         setTabAt(nextTab, i, ln);
    133.                         setTabAt(nextTab, i + n, hn);
    134.                         setTabAt(tab, i, fwd);
    135.                         advance = true;
    136.                     }
    137.                     //处理红黑树
    138.                     else if (f instanceof TreeBin) {
    139.                         TreeBin<K,V> t = (TreeBin<K,V>)f;
    140.                         TreeNode<K,V> lo = null, loTail = null;
    141.                         TreeNode<K,V> hi = null, hiTail = null;
    142.                         int lc = 0, hc = 0;
    143.                         for (Node<K,V> e = t.first; e != null; e = e.next) {
    144.                             int h = e.hash;
    145.                             TreeNode<K,V> p = new TreeNode<K,V>
    146.                                 (h, e.key, e.val, null, null);
    147.                             if ((h & n) == 0) {
    148.                                 if ((p.prev = loTail) == null)
    149.                                     lo = p;
    150.                                 else
    151.                                     loTail.next = p;
    152.                                 loTail = p;
    153.                                 ++lc;
    154.                             }
    155.                             else {
    156.                                 if ((p.prev = hiTail) == null)
    157.                                     hi = p;
    158.                                 else
    159.                                     hiTail.next = p;
    160.                                 hiTail = p;
    161.                                 ++hc;
    162.                             }
    163.                         }
    164.                         ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
    165.                             (hc != 0) ? new TreeBin<K,V>(lo) : t;
    166.                         hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
    167.                             (lc != 0) ? new TreeBin<K,V>(hi) : t;
    168.                         setTabAt(nextTab, i, ln);
    169.                         setTabAt(nextTab, i + n, hn);
    170.                         setTabAt(tab, i, fwd);
    171.                         advance = true;
    172.                     }
    173.                 }
    174.             }
    175.         }
    176.     }
    177. }
    178. 复制代码

    整个迁移的逻辑非常的复杂，并且代码很长，我们将其拆开看：

    3.5.1 对迁移步长的理解

    1. private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    2.     int n = tab.length, stride;
    3.     //构建每个线程迁移的步长，默认每个就是16个
    4.     if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
    5.         stride = MIN_TRANSFER_STRIDE; // subdivide range
    6.     /**
    7.      * 穿件扩容后新的table, 长度为原来的2倍
    8.      */
    9.     if (nextTab == null) {            // initiating
    10.         try {
    11.             @SuppressWarnings("unchecked")
    12.             Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
    13.             nextTab = nt;
    14.         } catch (Throwable ex) {      // try to cope with OOME
    15.             sizeCtl = Integer.MAX_VALUE;
    16.             return;
    17.         }
    18.         //赋给nextTable， 方便其他协助扩容的线程能否拿到新表
    19.         nextTable = nextTab;
    20.         transferIndex = n;
    21.     }
    22.    
    23.     int nextn = nextTab.length;
    24.     /**
    25.      * 构建一个fwd节点，hash值固定为-1
    26.      */
    27.     ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    28.     boolean advance = true;
    29.     boolean finishing = false; 
    30.     //从后往前遍历旧数组，每迁移一个就把旧数组的位置放一个fwd节点
    31.     for (int i = 0, bound = 0;;) {
    32.         Node<K,V> f; int fh;
    33.         while (advance) {
    34.             int nextIndex, nextBound;
    35.             if (--i >= bound || finishing)
    36.                 advance = false;
    37.             else if ((nextIndex = transferIndex) <= 0) {
    38.                 i = -1;
    39.                 advance = false;
    40.             }
    41.             else if (U.compareAndSwapInt
    42.                      (this, TRANSFERINDEX, nextIndex,
    43.                       nextBound = (nextIndex > stride ?
    44.                                    nextIndex - stride : 0))) {
    45.                 bound = nextBound;
    46.                 i = nextIndex - 1;
    47.                 advance = false;
    48.             }
    49.         }
    50.         
    51.         //省略for循环的其他逻辑........
    52.         
    53.       }  
    54.  }   
    55. 复制代码

    我们将重点关注代码截图展示：

    1. 首先线程进来先执行1处，它就是给每个线程分配迁移的任务段，默认就是16个，bound就是本次线程负责迁移的段尾
    2. 然后循环执行2处，从后往前一个一个迁移数据，迁移完成后，将fwd节点覆盖
    3. 表示整体迁移结束了

    我们用一个图来表示下它的分段：

    我们在用一个图来展示下

    3.5.2 迁移数据

    1. private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    2.     
    3.     //....省略其他代码......
    4.     
    5.     ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    6.     boolean advance = true;
    7.     boolean finishing = false; // to ensure sweep before committing nextTab
    8.     for (int i = 0, bound = 0;;) {
    9.         Node<K,V> f; int fh;
    10.         //1.省略分配任务的while循环
    11.         //2.省略迁移完成的判断
    12.         
    13.         //接下来就是迁移工作了
    14.         
    15.         //如果旧数组位置是null,则不用迁移，直接放一个fwd节点即可
    16.         //如果其他线程想要put元素，发现是fwd节点，则知道在扩容，此时将会参与扩容，将数据放到新数组中
    17.         else if ((f = tabAt(tab, i)) == null)
    18.             advance = casTabAt(tab, i, null, fwd);
    19.         //说明已经迁移过了，当每个线程迁移完成后，它还会重新检查一遍，确保没有遗漏    
    20.         else if ((fh = f.hash) == MOVED)
    21.             advance = true; // already processed
    22.         //这里就是将有数据的节点真正的迁移了    
    23.         else {
    24.             /**
    25.              * 这里要加锁，避免A线程迁移的过程中，B线程往旧的数组里put元素
    26.              * put先抢到锁，就先添加，迁移线程先抢到锁，则先迁移
    27.              */
    28.             synchronized (f) {
    29.                 if (tabAt(tab, i) == f) {
    30.                     Node<K,V> ln, hn;
    31.                     //处理链表
    32.                     if (fh >= 0) {
    33.                         //fh & n: 如果是0，说明是放到原位置，这个和HashMap一样的
    34.                         int runBit = fh & n;
    35.                         Node<K,V> lastRun = f;
    36.                         for (Node<K,V> p = f.next; p != null; p = p.next) {
    37.                             int b = p.hash & n;
    38.                             if (b != runBit) {
    39.                                 runBit = b;
    40.                                 lastRun = p;
    41.                             }
    42.                         }
    43.                         if (runBit == 0) {
    44.                             ln = lastRun;
    45.                             hn = null;
    46.                         }
    47.                         else {
    48.                             hn = lastRun;
    49.                             ln = null;
    50.                         }
    51.                         for (Node<K,V> p = f; p != lastRun; p = p.next) {
    52.                             int ph = p.hash; K pk = p.key; V pv = p.val;
    53.                             if ((ph & n) == 0)
    54.                                 ln = new Node<K,V>(ph, pk, pv, ln);
    55.                             else
    56.                                 hn = new Node<K,V>(ph, pk, pv, hn);
    57.                         }
    58.                         //放到新数组的【原位置】
    59.                         setTabAt(nextTab, i, ln);
    60.                         //放到新数组的【原位置 + oldCap】位置
    61.                         setTabAt(nextTab, i + n, hn);
    62.                         //旧数组放一个fwd节点
    63.                         setTabAt(tab, i, fwd);
    64.                         //再次向前推进
    65.                         advance = true;
    66.                     }
    67.                     //处理红黑树
    68.                     else if (f instanceof TreeBin) {
    69.                         TreeBin<K,V> t = (TreeBin<K,V>)f;
    70.                         TreeNode<K,V> lo = null, loTail = null;
    71.                         TreeNode<K,V> hi = null, hiTail = null;
    72.                         int lc = 0, hc = 0;
    73.                         for (Node<K,V> e = t.first; e != null; e = e.next) {
    74.                             int h = e.hash;
    75.                             TreeNode<K,V> p = new TreeNode<K,V>
    76.                                 (h, e.key, e.val, null, null);
    77.                             if ((h & n) == 0) {
    78.                                 if ((p.prev = loTail) == null)
    79.                                     lo = p;
    80.                                 else
    81.                                     loTail.next = p;
    82.                                 loTail = p;
    83.                                 ++lc;
    84.                             }
    85.                             else {
    86.                                 if ((p.prev = hiTail) == null)
    87.                                     hi = p;
    88.                                 else
    89.                                     hiTail.next = p;
    90.                                 hiTail = p;
    91.                                 ++hc;
    92.                             }
    93.                         }
    94.                         ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
    95.                             (hc != 0) ? new TreeBin<K,V>(lo) : t;
    96.                         hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
    97.                             (lc != 0) ? new TreeBin<K,V>(hi) : t;
    98.                         setTabAt(nextTab, i, ln);
    99.                         setTabAt(nextTab, i + n, hn);
    100.                         setTabAt(tab, i, fwd);
    101.                         advance = true;
    102.                     }
    103.                 }
    104.             }
    105.         }
    106.     }
    107. }
    108. 复制代码

    这里其实相对简单，我们简单画个图来展示下：

    3.5.3 迁移完成

    1. private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    2.     
    3.     //....省略其他代码.......
    4.    
    5.     for (int i = 0, bound = 0;;) {
    6.         Node<K,V> f; int fh;
    7.         while (advance) {
    8.             int nextIndex, nextBound;
    9.             if (--i >= bound || finishing)
    10.                 advance = false;
    11.             /**
    12.              * 迁移完成nextIndex = -1
    13.              */
    14.             else if ((nextIndex = transferIndex) <= 0) {
    15.                 i = -1;
    16.                 advance = false;
    17.             }
    18.             //....省略else if....
    19.         }
    20.         /**
    21.          * 迁移完成的判断
    22.          * 迁移到最后一个元素，i = -1
    23.          */
    24.         if (i < 0 || i >= n || i + n >= nextn) {
    25.             int sc;
    26.             if (finishing) {
    27.                 //所有线程迁移完成了，将nextTable 置为null
    28.                 nextTable = null;
    29.                 //将迁移后的新数组赋给table,此时table就是新数组了
    30.                 table = nextTab;
    31.                 /**
    32.                  * 计算新的扩容阈值
    33.                  * sizeCtl = 2n - 0.5n = 1.5n = 0.75 * 2n
    34.                  * JDK的开发者将位运算用的真是神乎其神
    35.                  */
    36.                 sizeCtl = (n << 1) - (n >>> 1);
    37.                 return;
    38.             }
    39.             /**
    40.              * 判断是否所有线程都完成了扩容
    41.              * sc - 1 是因为，协助扩容的时候sc + 1
    42.              */
    43.             if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
    44.                 if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
    45.                     return;
    46.                 finishing = advance = true;
    47.                 /**
    48.                  *  将数据长度赋给i,重新检查旧数组的所有位置，确保都迁移完毕，没有遗漏
    49.                  */
    50.                 i = n; 
    51.             }
    52.         }
    53.         
    54.         //......省略其他代码......
    55.         
    56.  }       
    57. 复制代码

    我们重点看下CAS的判断逻辑：

    外层判断(1) 为什么要对sizeCtl减1的操作呢？
    这个主要是和协助扩容有关。

    我们看下协助扩容的代码：

    我的初始容量是64，计算出来的rs值是固定的32793，然后触发扩容的第一个线程A会将sizeCtl修改为负数 -2145845246, 然后参与扩容的线程B会将sizeCtl修改为 -2145845246 + 1，参与扩容的线程C将sizeCtl修改为-2145845246 + 1 + 1， 接下来我们回到扩容完成的逻辑：

    所以这个内层判断和外层判断的逻辑就是检查是否所有线程都完成了扩容操作。

    如果从始至终都只有一个线程参与扩容这个判断也是成立的，因为sizeCtl的值先赋给了sc,然后通过CAS将sc - 1 赋给sizeCtl, 但是sc的值没变，所以内层判断肯定是成立的。

    我们在简单看下，put元素时出现hash冲突，并且hash=-1时的协助扩容：

    简单看下代码：

    1. final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
    2.     Node<K,V>[] nextTab; int sc;
    3.     //double check
    4.     if (tab != null && (f instanceof ForwardingNode) &&
    5.         (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
    6.         int rs = resizeStamp(tab.length);
    7.         //sc = sizeCtl) < 0 ：小于0表示扩容
    8.         while (nextTab == nextTable && table == tab &&
    9.                (sc = sizeCtl) < 0) {
    10.             /**
    11.              * 判断是否扩容完毕了。。   
    12.              * (sc >>> RESIZE_STAMP_SHIFT) != rs 判断我看在JDK17中拿掉了
    13.              */
    14.             if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
    15.                 sc == rs + MAX_RESIZERS || transferIndex <= 0)
    16.                 break;
    17.             //参与扩容    
    18.             if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
    19.                 transfer(tab, nextTab);
    20.                 break;
    21.             }
    22.         }
    23.         return nextTab;
    24.     }
    25.     return table;
    26. }
    27. 复制代码

    3.6 put元素过程总结

    1. 计算扰动计算出hash值，这个hash值永远是正数

    2. 如果没有初始化，就调用 initTable() 方法来进行初始化

    3. 如果没有 hash 冲突就直接 CAS 无锁插入

    4. 如果正在扩容，则当前线程协助扩容

    5. 如果存在 hash 冲突，就加锁来保证线程安全，两种情况：一种是链表形式就直接遍历到尾端插入，一种是红黑树就按照红黑树结构插入

    6. 如果该链表的数量大于阈值8并且数组长度大于64，就要先转换成红黑树的结构

    7. 如果添加成功就调用 addCount() 方法统计 size，并且检查是否需要扩容

    4.get()方法分析

    理解了put方法，再来看get就非常简单了

    1. public V get(Object key) {
    2.     Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    3.     //计算key的hash值
    4.     int h = spread(key.hashCode());
    5.     if ((tab = table) != null && (n = tab.length) > 0 &&
    6.         (e = tabAt(tab, (n - 1) & h)) != null) {
    7.         //从数组的桶中查找到
    8.         if ((eh = e.hash) == h) {
    9.             if ((ek = e.key) == key || (ek != null && key.equals(ek)))
    10.                 return e.val;
    11.         }
    12.         /**
    13.          * 从红黑树中查找
    14.          * hash < 0 只有是扩容或者红黑树在桶中的元素节点
    15.          */
    16.         else if (eh < 0)
    17.             return (p = e.find(h, key)) != null ? p.val : null;
    18.         //从链表中查找    
    19.         while ((e = e.next) != null) {
    20.             if (e.hash == h &&
    21.                 ((ek = e.key) == key || (ek != null && key.equals(ek))))
    22.                 return e.val;
    23.         }
    24.     }
    25.     return null;
    26. }
    27. 复制代码

    5.debug 分析多线程扩容

    准备测试数据：

    1. /**
    2.  * @author qiuguan
    3.  * @date 2022/11/24 23:40:24  星期四
    4.  */
    5. public class ConcurrentHashMapTest {
    6.  
    7.     public static void main(String[] args) {
    8.         /**
    9.          * 指定容量32，则table的初始容量是64
    10.          * 当达到 64 * 0.75 = 48 时触发扩容
    11.          */
    12.         ConcurrentHashMap<String, Integer> chm = new ConcurrentHashMap<>(32);
    13.  
    14.         //先放47个元素
    15.         for (int i = 1; i <= 47; i++) {
    16.             chm.put("jk" + i, i);
    17.         }
    18.  
    19.  
    20.         //Ea 的 hash值是: 2236, 在数组中的索引位置是: 60
    21.         //FB 的 hash值是: 2236, 在数组中的索引位置是: 60
    22.         int ea = "Ea".hashCode();
    23.         int fb = "FB".hashCode();
    24.         System.out.printf("Ea 的 hash值是: %s, 在数组中的索引位置是: %s\n", spread(ea), (64 -1) & spread(ea));
    25.         System.out.printf("FB 的 hash值是: %s, 在数组中的索引位置是: %s\n", spread(fb), (64 -1) & spread(fb));
    26.  
    27.         //再次添加元素会触发扩容
    28.         new Thread(() -> chm.put("Ea", 11)).start();
    29.         new Thread(() -> chm.put("FB", 22)).start();
    30.     }
    31.  
    32.     //将源码中计算hash值的逻辑拿出来s
    33.     static final int spread(int h) {
    34.         return (h ^ (h >>> 16)) & 0x7fffffff;
    35.     }
    36. }
    37. 复制代码

    关键位置打上断点：

    先让thread0(Ea)线程执行:

    然后让thread0开始迁移，迁移几个就行，因为"Ea"的在数组中位置是靠后的(index = 60)，而迁移是从后往前迁移的，所以确保"Ea"迁移完成后，我们切换到 "thread1"线程。

    在thread1线程进行协助扩容前，我先用几张图来演示下过程:

    1. thread0("Ea")触发扩容

    2. thread0("Ea")开始扩容并完成"Ea"数据的迁移工作

    1. thread1("FB")put元素发生hash碰撞并且桶中元素的hash值为-1，准备协助扩容

    接下来我们就从"thread1"视角看它是如何协助扩容的,首先要切换到"thread1"线程

    用一张图展示的话，大概就是下面这样

  • 相关阅读:
    matlab测量计算信号的相似度
    【Java面试】如果一个线程两次调用start()，会出现什么问题？
    c语言练习题79：设计停⻋系统
    如何把A3 pdf 文章打印成A4
    《21天精通TypeScript-3》-安装搭建TypeScript开发环境.md
    9.14小米笔试C++
    PHP 同城服务共享茶室软硬件结合小程序开发的注意事项？
    Android 桌面小组件 AppWidgetProvider
    RedisTemplate用法
    使用TF-IDF对文本集中的单篇文本制作词云
  • 原文地址：https://blog.csdn.net/BASK2311/article/details/128061881