ConcurrentHashMap 成员、方法分析

常量

 // 散列表数组(即table)长度最大限制
 private static final int MAXIMUM_CAPACITY = 1 << 30;
 // table默认长度
 private static final int DEFAULT_CAPACITY = 16;
 // 最大可能的数组长度,toArray方法使用(官方直译),常用方法中未涉及
 static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 //  并发级别, 之前的版本留下来的, 无用
 private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
 // 负载因子
 private static final float LOAD_FACTOR = 0.75f;
 // 链表转红黑树的阈值,9个节点开始转
 static final int TREEIFY_THRESHOLD = 8;
 // 红黑树转链表的阈值
 static final int UNTREEIFY_THRESHOLD = 6;
 // 链表转红黑树是数组最小长度, 当最小长度达到64, 并且链表长度达到8, 才开始转红黑树
 static final int MIN_TREEIFY_CAPACITY = 64;
 // 并发扩容时最小步长
 private static final int MIN_TRANSFER_STRIDE = 16;
 // 扩容相关, 计算扩容时生成的一个标识戳, 全局不变
 private static int RESIZE_STAMP_BITS = 16;
 // 并发扩容的最大线程数, 最大为65535
 private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
 // 扩容相关, 为16
 private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;

 /** 节点哈希字段的编码 */
 // node节点的hash为-1时, 表示当前节点是FWD节点, 已经迁移完成
 static final int MOVED     = -1; 
 // node节点的hash为-2, 表示当前节点是TreeBin节点
 static final int TREEBIN   = -2; 
 // node节点的hash为-3, 表示当前节点为ReservationNode
 static final int RESERVED  = -3; /


成员变量

  // table数组
 transient volatile Node<K,V>[] table;
 // 扩容过程中的新table, 扩容结束后会将nextTable设置为null
 private transient volatile Node<K,V>[] nextTable;
 // LongAdder中的baseCount, 未发生竞争时 或者 当前LongAdder处于加锁状态时, 增量累积到baseCount中
 private transient volatile long baseCount;
 /**
  * sizeCtl < 0
  * 1. -1表示当前table正在初始化(有线程正在创建table数组), 当前线程需要自旋等待
  * 2. 表示当前table数组正在进行扩容, 高16位表示扩容的标识戳, 低16位表示: (1 + nThread) 当前参与并发扩容的线程数量(这个状态最重要)
  *
  * sizeCtl = 0
  * 表示创建table数组时, 使用DEFAULT_CAPACITY为大小
  *
  * sizeCtl > 0
  * 1. 如果table为初始化, 表示初始化大小
  * 2. 如果table已经初始化, 表示下次扩容时的阈值(n * 0.75)
  */
 private transient volatile int sizeCtl;
 // 扩容过程中, 记录当前进度, 所有线程都需要从transferIndex中分配区间任务, 去执行自己相应的区间
 private transient volatile int transferIndex;

 /**
  * LongAdder中的cellBusy
  * 0 表示当前LongAdder对象无锁状态
  * 1 表示当前LongAdder对象加锁状态, 只有一个对象能持有加锁状态
  */
 private transient volatile int cellsBusy;

 /**
  * LongAdder中的cells数组, 当baseCount发生竞争后, 会创建cells数组
  * 线程会通过计算hash值, 取到自己的cell, 将增量累加到指定cell中
  * 总数 = sum(cells) + baseCount
  */
 private transient volatile CounterCell[] counterCells;
 

内部类

链表节点Node

 static class Node<K,V> implements Map.Entry<K,V> {
      // 节点hash值,经过扰动运算得出来的
      final int hash;
      final K key;
      volatile V val;
      // 后继节点
      volatile Node<K,V> next;

      Node(int hash, K key, V val, Node<K,V> next) {
          this.hash = hash;
          this.key = key;
          this.val = val;
          this.next = next;
      }
 }

红黑树节点TreeNode

 static final class TreeNode<K,V> extends Node<K,V> {
 	   // 父节点
       TreeNode<K,V> parent; 
       // 左子节点
       TreeNode<K,V> left;
       // 右子节点
       TreeNode<K,V> right;
       TreeNode<K,V> prev;    // needed to unlink next upon deletion
       boolean red;

       TreeNode(int hash, K key, V val, Node<K,V> next,
                TreeNode<K,V> parent) {
           super(hash, key, val, next);
           this.parent = parent;
       }
 }

红黑树链表节点TreeBin

 static final class TreeBin<K,V> extends Node<K,V> {
      // 红黑树根节点
      TreeNode<K,V> root;
      // 链表的头节点
      volatile TreeNode<K,V> first;
      // 等待者线程(当前lockState是读锁状态)
      volatile Thread waiter;
      /**
       * 1. 写锁状态 写是独占状态, 以table来看, 真正进入到TreeBin中的写线程, 同一时间只有一个
       * 2. 读锁状态 读锁是共享的, 同一时刻可以有多个线程, 同时进入到TreeBin对象中获取数据, 每一个线程都会给lockState + 1
       * 3. 等待者状态(写线程在等待), 当TreeBin中有读线程目前正在读取数据时, 写线程无法修改数据, 那么就将lockState的最低两位设置为0b,10
       */
      volatile int lockState;
      // 锁状态的;值
      static final int WRITER = 1; 
      static final int WAITER = 2; 
      static final int READER = 4; 
 }

扩容完成的红黑树节点ForwardingNode

 static final class ForwardingNode<K,V> extends Node<K,V> {
 	  // 扩容中临时table数组
      final Node<K,V>[] nextTable;
      // ForwardingNode是node的子类, hash值为moved(-1), nextTable指向了扩容是临时存储node的新table
      // 写线程: 需要参与并发扩容 读线程: 调用find方法到新表继续查询
      ForwardingNode(Node<K,V>[] tab) {
          super(MOVED, null, null, null);
          this.nextTable = tab;
      }
 }

部分方法

扰动运算

 static final int spread(int h) {
 	 // 将原hash与原hash的高16位进行异或, 然后再和HASH_BITS进行位与预算
     return (h ^ (h >>> 16)) & HASH_BITS;
 }

在 table 的长度较小的时候,让高位也参与运算,降低 hash冲突的概率。

获取>=c 最小2的次方数

 private static final int tableSizeFor(int c) {
     int n = c - 1;
     n |= n >>> 1;
     n |= n >>> 2;
     n |= n >>> 4;
     n |= n >>> 8;
     n |= n >>> 16;
     return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
 }

获取数组指定下标位置i的元素

 @SuppressWarnings("unchecked")
 static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
     return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
 }

使用Unsafe通过内存地址的操作来完成,Unsafe类存在于sun.misc包中,其内部方法操作可以像C的指针一样直接操作内存,Unsafe类中的所有方法都是native修饰的,也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。

通过CAS将table中指定位置i设置为新值v

 // c:期望值,v新值
 static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                     Node<K,V> c, Node<K,V> v) {
     return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
 }

table数组i位置设置值v

 static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
     U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
 }

tabAt获取指定hash槽

 tabAt(tab, i = (n - 1) & hash)
     
   static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }

getObjectVolatile#
public native Object getObjectVolatile(Object o, long offset);
此方法和上面的getObject功能类似,不过附加了’volatile’加载语义,也就是强制从主存中获取属性值。类似的方法有getIntVolatile、getDoubleVolatile等等。这个方法要求被使用的属性被volatile修饰,否则功能和getObject方法相同。

扩容标识戳

 // 扩容标识戳,标识戳一致时才能参与扩容
 static final int resizeStamp(int n) {
     // numberOfLeadingZeros: 这个数据的二进制串中从最左边算起连续的“0”的总数量。因为int类型的数据长度为32所以高位不足的地方会以“0”填充
     return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
 }

用于计数map大小的LongAdder介绍

LongAdder类是JDK1.8新增的一个原子性操作类。AtomicLong通过CAS算法提供了非阻塞的原子性操作,相比受用阻塞算法的同步器来说性能已经很好了,但是JDK开发组并不满足于此,因为非常搞并发的请求下AtomicLong的性能是不能让人接受的。
如下AtomicLong 的incrementAndGet的代码,虽然AtomicLong使用CAS算法,但是CAS失败后还是通过无限循环的自旋锁不多的尝试,这就是高并发下CAS性能低下的原因所在。源码如下:

public final long incrementAndGet() {
        for (;;) {
            long current = get();
            long next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

高并发下N多线程同时去操作一个变量会造成大量线程CAS失败,然后处于自旋状态,导致严重浪费CPU资源,降低了并发性。既然AtomicLong性能问题是由于过多线程同时去竞争同一个变量的更新而降低的,那么如果把一个变量分解为多个变量,让同样多的线程去竞争多个资源。
在这里插入图片描述

LongAdder则是内部维护一个Cells数组,每个Cell里面有一个初始值为0的long型变量,在同等并发量的情况下,争夺单个变量的线程会减少,这是变相的减少了争夺共享资源的并发量,另外多个线程在争夺同一个原子变量时候,如果失败并不是自旋CAS重试,而是尝试获取其他原子变量的锁,最后当获取当前值时候是把所有变量的值累加后再加上base的值返回的。
LongAdder维护了要给延迟初始化的原子性更新数组和一个基值变量base数组的大小保持是2的N次方大小,数组表的下标使用每个线程的hashcode值的掩码表示,数组里面的变量实体是Cell类型。
Cell 类型是Atomic的一个改进,用来减少缓存的争用,对于大多数原子操作字节填充是浪费的,因为原子操作都是无规律的分散在内存中进行的,多个原子性操作彼此之间是没有接触的,但是原子性数组元素彼此相邻存放将能经常共享缓存行,也就是伪共享。所以这在性能上是一个提升。
另外由于Cells占用内存是相对比较大的,所以一开始并不创建,而是在需要时候再创建,也就是惰性加载,当一开始没有空间时候,所有的更新都是操作base变量。

构造函数

 // 默认构造函数
 public ConcurrentHashMap() {
 }

 // 带容量参数的构造函数
 public ConcurrentHashMap(int initialCapacity) {
     if (initialCapacity < 0)
     	 // 小于0,抛出异常
         throw new IllegalArgumentException();
     // 大于 最大值/2,则为容量为最大值
     // 否则,取大于(initialCapacity+ initialCapacity/2 + 1)的最小2 的次方值,即如果initialCapacity为8,则cap > (8+4+1),cap = 16
     int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                MAXIMUM_CAPACITY :
                tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
     this.sizeCtl = cap;
 }
 
 // 带初始集合数据参数的构造函数
 public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
 	 // 默认容量为16
     this.sizeCtl = DEFAULT_CAPACITY;
     putAll(m);
 }

 // 容量和负载因子
 public ConcurrentHashMap(int initialCapacity, float loadFactor) {
     this(initialCapacity, loadFactor, 1);
 }
 
 // concurrencyLevel,并发线程数 
 public ConcurrentHashMap(int initialCapacity,
                          float loadFactor, int concurrencyLevel) {
     if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
         throw new IllegalArgumentException();
     if (initialCapacity < concurrencyLevel) 
     	 // 初始容量参数小于并发线程数,将初始容量参数赋值为并发线程数
         initialCapacity = concurrencyLevel;
     // 计算数组长度
     long size = (long)(1.0 + (long)initialCapacity / loadFactor);
     int cap = (size >= (long)MAXIMUM_CAPACITY) ?
         MAXIMUM_CAPACITY : tableSizeFor((int)size);
     this.sizeCtl = cap;
 }

ConcurrentHashMap构造函数的负载因子 与hashMap的负载因子不同。ConcurrentHashMap构造中的负载因子的作用是,与initialCapacity一起确定ConcurrentHashMap容量的大小,后续扩容使用的都是默认0.75的负载因子进行扩容

put()-方法入口

 public V put(K key, V value) {
     return putVal(key, value, false);
 }

putVal()-添加节点

 // put 和 putIfAbsent的实现
 final V putVal(K key, V value, boolean onlyIfAbsent) {
 	 // null键或null值,抛出异常
     if (key == null || value == null) throw new NullPointerException();
     // 扰动运算,将key的hash值本身与hash值的高16位进行异或, 然后在与32位的1进行位与预算, 得出新的hash值
     int hash = spread(key.hashCode());
     int binCount = 0;
     // 自旋
     for (Node<K,V>[] tab = table;;) {
         Node<K,V> f; int n, i, fh;
         // ConcurrentHashMap初始化是懒汉式,初次put时, 没有初始化table, 所以先初始化table
         if (tab == null || (n = tab.length) == 0)
         	 // 初始化table
             tab = initTable();
         // n为数组长度, 将hash值与(数组长度 - 1)进行位与预算, 获取该下标的node
         else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
             // 如果数组在该下标的位置没有node, 通过CAS将key和value构造成node填入数组内
             // 参数1: 数组
             // 参数2: 下标
             // 参数3: 期望值
             // 参数4: 要设置的新值
             if (casTabAt(tab, i, null,
                          new Node<K,V>(hash, key, value, null)))
                 // CAS操作成功,退出循环
                 break;                   
         }
         // 如果该下标位置有node, 且该node的hash值为moved(即-1), 说明当前concurrenthashmap正在扩容, 那么本次操作将会帮助扩容
         else if ((fh = f.hash) == MOVED)
             tab = helpTransfer(tab, f);
         else {
             // node存在, 并且该下标位置不是扩容状态
             // 扩容是一个下标一个下标进行的, 此时当前concurrenthashmap也可能在扩容, 但是还没处理到该下标, 该下标可以进行put操作, 并且该线程不会帮助扩容
             V oldVal = null;
             // 锁住该node, 该node就是该下标位置的第一个node
             synchronized (f) {
                 // 再次确认该下标加锁前该node有没有发生变化
                 if (tabAt(tab, i) == f) {
                     // fh是该node的hash值, 如果hash值为正数, 说明该下标是按照链表存储的
                     if (fh >= 0) {
                         binCount = 1;
                         // 遍历该链表
                         for (Node<K,V> e = f;; ++binCount) {
                             K ek;
                             // 如果节点e的hash值等于hash, 并且key值也相等, 则需要更新value
                             if (e.hash == hash &&
                                 ((ek = e.key) == key ||
                                  (ek != null && key.equals(ek)))) {
                                 oldVal = e.val;
                                 if (!onlyIfAbsent)
                                 	 // 更新value
                                     e.val = value;
                                 break;
                             }
                             // 如果链表中不存在这个key, 则添加到链表末尾
                             Node<K,V> pred = e;
                             if ((e = e.next) == null) {
                                 pred.next = new Node<K,V>(hash, key, value, null);
                                 // 添加成功,退出循环
                                 break;
                             }
                         }
                     }
                     // fh<0 代表该下标位置存储的是红黑树, 因为上面已经判断未在扩容了, 所以这里只能是红黑树
                     else if (f instanceof TreeBin) {
                         Node<K,V> p;
                         binCount = 2;
                         // 将节点插入到红黑树中,并返回旧节点
                         if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
                         	 // 旧节点不为空,则为更新旧值 
                             oldVal = p.val;
                             if (!onlyIfAbsent)
                                 p.val = value;
                         }
                     }
                 }
             }
             // binCount为table数组在该下标中的节点个数,
             // 判断binCount是否为0,为0则表示首节点发生变化,不需要做链表转红黑树
             // 不为0,则跳出循环后判断binCount是否满足转换为红黑树的条件
             if (binCount != 0) {
                 // 如果binCount >= 8, 则将该节点变为红黑树
                 // 新增的情况,在链表尾部添加节点完成直接退出循环, 并未将binCount+1, 所以其实是9个节点时开始转红黑树
                 // 如果刚好更新第8个节点,更新完也会转红黑树
                 if (binCount >= TREEIFY_THRESHOLD)
                     treeifyBin(tab, i);
                 if (oldVal != null)
                     return oldVal;
                 break;
             }
         }
     }
     // 总node数+1, 该方法中若满足条件会进行扩容
     addCount(1L, binCount);
     return null;
 }

第一次进入initTable

initTable()-初始化数组

 private final Node<K,V>[] initTable() {
     Node<K,V>[] tab; int sc;
     while ((tab = table) == null || tab.length == 0) {
         // table为空时, 如果sizeCtl<0, 说明有另一个线程在初始化table
         if ((sc = sizeCtl) < 0)
             // 放弃CPU执行权, 重新竞争CPU执行权
             Thread.yield(); 
         // sizeCtl>0, 说明没有线程竞争初始化table, 使用CAS将sizeCtl设置为-1, 代表初始化中
         else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
             try {
                 // 再次判断table是否为空
                 if ((tab = table) == null || tab.length == 0) {
                     // sc为构造函数为sizeCtl赋的值, 如果使用的是默认构造函数, 则sc为0, 使用默认的容量为16, 反之则使用
                     // 计算数组长度
                     int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                     @SuppressWarnings("unchecked")
                     // 初始化长度为n的table
                     Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                     table = tab = nt;
                     // sc重新赋值为数组长度的0.75倍
                     sc = n - (n >>> 2);
                 }
             } finally {
                 // 更新sizeCtl
                 sizeCtl = sc;
             }
             break;
         }
     }
     return tab;
 }

while中循环设置sizeCtl并初始化数组
如果sizeCtl<0 说明其他线程已经在初始化,说明本线程不需要再初始化,Thread.yield();暂时让出cpu。从新获得cpu后再检测是不是已经初始化完毕
如果不小于0 ,sizeCtl>0表示初始容量。 设置成-1,向其他线程说明自己已经在初始化
初始化完毕之后再把sizeCtl设置大于0,sizeCtl变为原来的四分之三
sizeCtl在初始化后存储的是扩容门槛;
扩容门槛写死的是桶数组大小的0.75倍,桶数组大小即map的容量,也就是最多存储多少个元素。

如果数组上的位置还是空,cas在数组上设置值

   if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                 

如果不为空,需要放入链表或者红黑树

 else {
             // node存在, 并且该下标位置不是扩容状态
             // 扩容是一个下标一个下标进行的, 此时当前concurrenthashmap也可能在扩容, 但是还没处理到该下标, 该下标可以进行put操作, 并且该线程不会帮助扩容
             V oldVal = null;
             // 锁住该node, 该node就是该下标位置的第一个node
             synchronized (f) {
                 // 再次确认该下标加锁前该node有没有发生变化
                 if (tabAt(tab, i) == f) {
                     // fh是该node的hash值, 如果hash值为正数, 说明该下标是按照链表存储的
                     if (fh >= 0) {
                         binCount = 1;
                         // 遍历该链表
                         for (Node<K,V> e = f;; ++binCount) {
                             K ek;
                             // 如果节点e的hash值等于hash, 并且key值也相等, 则需要更新value
                             if (e.hash == hash &&
                                 ((ek = e.key) == key ||
                                  (ek != null && key.equals(ek)))) {
                                 oldVal = e.val;
                                 if (!onlyIfAbsent)
                                 	 // 更新value
                                     e.val = value;
                                 break;
                             }
                             // 如果链表中不存在这个key, 则添加到链表末尾
                             Node<K,V> pred = e;
                             if ((e = e.next) == null) {
                                 pred.next = new Node<K,V>(hash, key, value, null);
                                 // 添加成功,退出循环
                                 break;
                             }
                         }
                     }
                     // fh<0 代表该下标位置存储的是红黑树, 因为上面已经判断未在扩容了, 所以这里只能是红黑树
                     else if (f instanceof TreeBin) {
                         Node<K,V> p;
                         binCount = 2;
                         // 将节点插入到红黑树中,并返回旧节点
                         if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
                         	 // 旧节点不为空,则为更新旧值 
                             oldVal = p.val;
                             if (!onlyIfAbsent)
                                 p.val = value;
                         }
                     }
                 }
             }
             // binCount为table数组在该下标中的节点个数,
             // 判断binCount是否为0,为0则表示首节点发生变化,不需要做链表转红黑树
             // 不为0,则跳出循环后判断binCount是否满足转换为红黑树的条件
             if (binCount != 0) {
                 // 如果binCount >= 8, 则将该节点变为红黑树
                 // 新增的情况,在链表尾部添加节点完成直接退出循环, 并未将binCount+1, 所以其实是9个节点时开始转红黑树
                 // 如果刚好更新第8个节点,更新完也会转红黑树
                 if (binCount >= TREEIFY_THRESHOLD)
                     treeifyBin(tab, i);
                 if (oldVal != null)
                     return oldVal;
                 break;
             }
         }
     }
锁头节点
在链表上找到相等值,替换,否则尾插
链表长超过8,treeifyBin

transfer()-扩容方法

扩容方法有两个入参,一个源tab,一个是扩容后的tab,首次出发扩容,进入transfer方法。扩容后的tab为空

  private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
     int n = tab.length, stride;
     // 根据CPU核数计算出步长, 用于分隔扩容任务, 方便其余线程帮助扩容, 最小为16
     if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
         stride = MIN_TRANSFER_STRIDE; // subdivide range
     // 判断nextTable是否为空, nextTable是暂时存储扩容后的node数组, 第一次进入这个方法的线程才会发现nextTable为空
     // 前文提到的helpTransfer也会调用该方法, 当helpTransfer调用该方法时nextTable不为空
     if (nextTab == null) {            // initiating
         try {
             @SuppressWarnings("unchecked")
             Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
             // 初始化nextTable为table长度的2倍
             nextTab = nt;
         } catch (Throwable ex) {      // try to cope with OOME
             // 如果发生了异常, 则将sizeCtl设为Integer的最大值, 因为前文提过数组长度大于1<<30就不能再扩容了
             sizeCtl = Integer.MAX_VALUE;
             return;
         }
         nextTable = nextTab;
         // 将transferIndex赋值为原数组table的长度
         transferIndex = n;
     }
     // 新数组的长度
     int nextn = nextTab.length;
     // ForwardingNode节点, 当某个桶位数据处理完毕后, 将此桶位设置为ForwardingNode节点
     ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
     // 推进标记
     boolean advance = true;
     // 完成标记
     boolean finishing = false; // to ensure sweep before committing nextTab
     // i: 表示分配给当前线程任务执行到的数组下标; bound: 表示分配给当前线程任务的下界限制
     // 自旋
     for (int i = 0, bound = 0;;) {
         // f: 当前数组下标的头节点; fh: 头节点的hash
         Node<K,V> f; int fh;
         // 该while循环的作用有两点 1.将扩容任务根据步长分块 2.确定本次循环要rehash的下标节点
         while (advance) {
             // nextIndex: 分配任务的开始下标; nextBound: 分配任务的结束下标
             int nextIndex, nextBound;
             // 条件1: --i >= bound
             // true-> 表示当前任务尚未完成, 需要处理相应的下标数据
             // false-> 表示当前线程任务已经完成或还未开始分配
             if (--i >= bound || finishing)
                 advance = false;
             // 前置条件: 当前任务已完成或未分配
             // true-> 表示table数组所有区间都已分配完成, 设置当前线程的i为-1, 退出循环后, 执行退出迁移任务相关的逻辑
             // false-> 当前table数组还有区间可以分配
             else if ((nextIndex = transferIndex) <= 0) {
                 i = -1;
                 advance = false;
             }
             // 前置条件: 当前线程需要分配任务, 当前table数组还有区间可以分配
             // true-> 当前线程分配任务成功
             // false-> 当前线程分配任务失败, 区间扩容任务分配给了其他线程
             else if (U.compareAndSwapInt
                      (this, TRANSFERINDEX, nextIndex,
                       nextBound = (nextIndex > stride ?
                                    nextIndex - stride : 0))) {
                 // 设置下个边界
                 bound = nextBound;
                 // 设置table数组下标
                 i = nextIndex - 1;
                 advance = false;
             }
         }
         // 条件1: i < 0
         // true-> 当前线程为分配区间任务, 或所分配的任务都已经执行完成, 未分配新的任务
         if (i < 0 || i >= n || i + n >= nextn) {
             int sc;
             // 任务完成状态已经设置成true, 代表所有区间任务都已经完成了
             if (finishing) {
                 // 将临时新table设置为null
                 nextTable = null;
                 // 新table赋值为table
                 table = nextTab;
                 // 将sizeCtl设置为扩容阈值
                 sizeCtl = (n << 1) - (n >>> 1);
                 return;
             }
             // 将sizeCtl-1, 表示参与扩容的线程减少1
             if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                 // true-> 当前线程不是最后一个退出transfer的线程
                 if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                     // 直接退出
                     return;
                 // 前置条件: 当前线程是最后一个退出transfer的线程
                 // 设置任务完成状态为完成
                 finishing = advance = true;
                 i = n; // recheck before commit
             }
         }
         // 如果该下标内没有数据, 则将该下标处的节点(即为null)放入ForwardingNode, 代表该下标rehash结束
         else if ((f = tabAt(tab, i)) == null)
             advance = casTabAt(tab, i, null, fwd);
         // 如果该下标处的节点的hash值为-1(即ForwardingNode的hash值), 代表已经rehash结束, 继续下一次循环
         else if ((fh = f.hash) == MOVED)
             advance = true; // already processed
         else {
             // 真正开始扩容, 锁住该下标的第一个node
             synchronized (f) {
                 // 再次判断该node是否发生改变
                 if (tabAt(tab, i) == f) {
                     Node<K,V> ln, hn;
                     // 如果该node的hash值>=0, 代表该node是链表节点
                     if (fh >= 0) {
                         // 将该node的hash值和原数组长度进行位与运算
                         int runBit = fh & n;
                         Node<K,V> lastRun = f;
                         // 遍历链表, runBit为末尾节点的位与运算结果, lastRun是和末尾节点位与运算结果一致的最后一个节点
                         // 即lastRun之后的节点不需要再二次遍历, 遍历到此时, 直接将lastRun之后的链表放入新数组中即可, 因为位与运算结果一致
                         // 遍历完成后, 旧链表在新数组中的下标位置为i, i+n, ln为新数组下标i的末尾节点, hn为新数组下标i+n的末尾节点
                         for (Node<K,V> p = f.next; p != null; p = p.next) {
                             int b = p.hash & n;
                             if (b != runBit) {
                                 runBit = b;
                                 lastRun = p;
                             }
                         }
                         if (runBit == 0) {
                             ln = lastRun;
                             hn = null;
                         }
                         else {
                             hn = lastRun;
                             ln = null;
                         }
                         // 遍历链表, 将链表内的node重新分配到新nextTable的i位置和i+n位置
                         // 原始的链表会倒序分到两个下标内, 越靠后的node在新链表里越靠前
                         // 遍历完成后, ln为新nextTable中i位置的头节点, hn为新nextTable中i+n位置的头节点
                         for (Node<K,V> 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<K,V>(ph, pk, pv, ln);
                             else
                                 hn = new Node<K,V>(ph, pk, pv, hn);
                         }
                         // 更新新的nextTab, 并将原table的该下标位置放入ForwardingNode
                         setTabAt(nextTab, i, ln);
                         setTabAt(nextTab, i + n, hn);
                         setTabAt(tab, i, fwd);
                         advance = true;
                     }
                     // 该node为红黑树
                     else if (f instanceof TreeBin) {
                         // 将链表节点转化为红黑树节点
                         TreeBin<K,V> t = (TreeBin<K,V>)f;
                         // 在新table中i位置的红黑树节点
                         TreeNode<K,V> lo = null, loTail = null;
                         // 在新table中i+n位置的红黑树节点
                         TreeNode<K,V> hi = null, hiTail = null;
                         int lc = 0, hc = 0;
                         // 红黑树节点是维护了一个链表的,e.next即可取出后继节点
                         for (Node<K,V> e = t.first; e != null; e = e.next) {
                             int h = e.hash;
                             TreeNode<K,V> p = new TreeNode<K,V>
                                 (h, e.key, e.val, null, null);
                             if ((h & n) == 0) {
                                 if ((p.prev = loTail) == null)
                                     lo = p;
                                 else
                                     loTail.next = p;
                                 loTail = p;
                                 ++lc;
                             }
                             else {
                                 if ((p.prev = hiTail) == null)
                                     hi = p;
                                 else
                                     hiTail.next = p;
                                 hiTail = p;
                                 ++hc;
                             }
                         }
                         // 如果树的node数量<=6, 则将红黑树转换为链表
                         ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                             (hc != 0) ? new TreeBin<K,V>(lo) : t;
                         hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                             (lc != 0) ? new TreeBin<K,V>(hi) : t;
                         // 将新树或链表放到新的table对应的下标里
                         // 并将原table的该下标位置放入ForwardingNode
                         setTabAt(nextTab, i, ln);
                         setTabAt(nextTab, i + n, hn);
                         setTabAt(tab, i, fwd);
                         advance = true;
                     }
                 }
             }
         }
     }
 }

(1)新桶数组大小是旧桶数组的两倍(如果nextTab为空);
(2)遍历旧桶数组,迁移元素先从靠后的桶开始;
(3)迁移完成的桶在里面放置一ForwardingNode类型的元素,标记该桶迁移完成;
(4)迁移时根据hash&n是否等于0把桶中元素分化成两个链表或树;
(5)低位链表(树)存储在原来的位置;
(6)高们链表(树)存储在原来的位置加n的位置;
(7)迁移元素时会锁住当前桶,也是分段锁的思想;
(8)完成迁移之后会将table设置为扩容后的hash桶

  table = nextTab;

helpTransfer()-帮助扩容

helpTransfer 会在put,remove,get时发现当前槽的头节点为MOVE状态时 也就是已经转换为ForwardingNode,代表当前节点已经转移完毕,整个ConcurrentHashMap还正在扩容,说明整个concurrenHashMap正在扩容。那么进入helpTransfer方法,协助进行扩容,直到扩容完成,那么如果当前需要操作的节点还不是ForwardingNode即还没有完成扩容操作,那么会直接使用源tab,进行操作,对于写操作,也就是说,扩容期间,除了锁住头节点的槽,和已经扩容完成的节点,其他节点依然正常读写。不会因为访问这些节点进入协助扩容!可见ConcurrentHashMap对锁粒度的控制十分细。

 final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
     Node<K,V>[] nextTab; int sc;
     // 如果table不为空并且该下标的第一个node为ForwardingNode(ForwardingNode是一个代表扩容完毕的特殊node)
     // 并且存储扩容后数据的nextTable不为空
     if (tab != null && (f instanceof ForwardingNode) &&
         (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
         // 获取扩容标识戳
         int rs = resizeStamp(tab.length);
         // sizeCtl < 0代表正在扩容
         while (nextTab == nextTable && table == tab &&
                (sc = sizeCtl) < 0) {
             // 条件1: 判断当前线程获取到的扩容标识戳与通过sc计算得出的是否一致,不一致则不是同一批次扩容,退出循环
             // 条件2: JDK1.8 中有bug jira已经提出来了 其实想表达的是 =  sc == (rs << 16 ) + 1, true-> 表示扩容完毕,当前线程不需要再参与进来了 false-> 扩容还在进行中,当前线程可以参与(其他人的解释,楼主不太懂)
             // 条件3: JDK1.8 中有bug jira已经提出来了 其实想表达的是 = sc == (rs<<16) + MAX_RESIZERS(其他人的解释,楼主不太懂)
             // 条件4: transferIndex表示扩容剩余任务区间,<=0则表示扩容任务已分配完毕
             if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                 sc == rs + MAX_RESIZERS || transferIndex <= 0)
                 break;
             // 通过CAS将SIZECTL + 1
             if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                 // 扩容
                 transfer(tab, nextTab);
                 break;
             }
         }
         // 返回扩容后的table
         return nextTab;
     }
     return table;
 }

判断条件为必须为已扩容完成的ForwardingNode,从ForwardingNode中获取nextTab。如果补上扩容完成的ForwardingNode,那么直接返回tab。
这是因为当前hash槽在没有变为ForwardingNode之前,当前tab的节点还没有被改变,那么直接是使用当前。
helpTransfer本还是调用,transfer方法进行扩容,调用transfer时。会传一个nextTab进去,ForwardingNode节点中存储了nextTab。,进入transfer方法后,依然是每个hash槽进行遍历,对于已经完成的节点直接跳过。

红黑数相关操作

tryPresize

看回之前的 treeifyBin 当map的length不足64时,扩容,而不是转化成红黑树

 private final void tryPresize(int size) {
 //如果大小为MAXIMUM_CAPACITY最大总量的一半,那么直接扩容为MAXIMUM_CAPACITY,否则计算最小幂次方
        int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
            tableSizeFor(size + (size >>> 1) + 1);
        int sc;
          //如果sizeCtl为正数或0
        while ((sc = sizeCtl) >= 0) {
            Node<K,V>[] tab = table; int n;
             //如果table还未进行初始化
            if (tab == null || (n = tab.length) == 0) {
                n = (sc > c) ? sc : c;
                 //cas修改sizeCtl为-1,表示table正在进行初始化
                if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                    try {
                     //确认其他线程没有对table修改
                        if (table == tab) {
                            @SuppressWarnings("unchecked")
                            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                            table = nt;
                            //0.75*n
                            sc = n - (n >>> 2);
                        }
                    } finally {
                        sizeCtl = sc;
                    }
                }
            }
             //如果扩容大小没有达到阈值,或者超过最大容量
            else if (c <= sc || n >= MAXIMUM_CAPACITY)
                break;
            else if (tab == table) {
             /**生成表的生成戳,每个n都有不同的生成戳
             * static final int resizeStamp(int n) {
             *   return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
             *    }
             *   Integer.numberOfLeadingZeros(n)在指定 int 值的二进制补码表示形式中最高位(最左边)的 1 位之前,返回零位的数量
             * 例如 n为16 0001 0000 则Integer.numberOfLeadingZeros(n)为27,因为n为2的幂次方,因此不同的n此结果也不同
             * 然后与(1 << (RESIZE_STAMP_BITS - 1)) | ,相当于2^15 | n中0的个数。
             * (因此其左移16位后符号位为1,结果肯定是个负数)
             */
                int rs = resizeStamp(n);
                if (sc < 0) {
                    Node<K,V>[] nt;
                    /**1.第一个判断 sc右移RESIZE_STAMP_SHIFT位,也就是比较高ESIZE_STAMP_BITS位生成戳和rs是否相等
                    * 相等则代表是同一个n,是在同一容量下进行的扩容,
                    *  2.第二个和第三个判断 判断当前帮助扩容线程数是否已达到MAX_RESIZERS最大扩容线程数
                    *  3.第四个和第五个判断 为了确保transfer()方法初始化完毕
                    */
                    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);
                }
                 /**如果没有线程在进行扩容,那么cas修改sizeCtl值,作为扩容的发起,rs左移RESIZE_STAMP_SHIFT位+2
                 * 上面说了,左移RESIZE_STAMP_SHIFT位,肯定是个负数,代表有一个线程正在进行扩容
                 * 此时sizeCtl高RESIZE_STAMP_BITS位为生成戳,低RESIZE_STAMP_SHIFT位为扩容线程数
                 */
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
            }
        }
    }

TreeBin()-红黑树链表节点构造函数

将链表转换为红黑树

 TreeBin(TreeNode<K,V> b) {
     // 设置节点hash为-2, 表示此节点是TreeBin节点
     super(TREEBIN, null, null, null);
     // 将b赋值为first,表示红黑树链表的头节点
     this.first = b;
     // 用来表示红黑树根节点
     TreeNode<K,V> r = null;

     // x表示遍历的当前插入节点
     for (TreeNode<K,V> x = b, next; x != null; x = next) {
         next = (TreeNode<K,V>)x.next;
         // 设置当前插入节点的左右子树为null
         x.left = x.right = null;
         // 第一次遍历,r为空,设置当前插入节点为根节点,赋值给r
         if (r == null) {
             x.parent = null;
             x.red = false;
             r = x;
         }
         // r不为null,则非第一次遍历
         else {
             // k表示插入节点的key
             K k = x.key;
             // h表示插入节点的hash
             int h = x.hash;
             // kc表示插入节点key的class类型
             Class<?> kc = null;
             // p 表示查找插入节点的父节点
             // 从根节点开始遍历,查找插入节点应该放置的位置
             for (TreeNode<K,V> p = r;;) {
                 // dir的值为-1或1, -1表示插入节点的hash值大于当前p节点的hash; 1表示插入节点的hash值小于当前p节点的hash
                 // ph p节点的hash
                 int dir, ph;
                 // 临时节点p的key
                 K pk = p.key;
                 // 插入节点的hash值小于当前节点
                 if ((ph = p.hash) > h)
                     // 插入节点可能需要插入到当前节点的左子节点 或者继续在左子树上查找
                     dir = -1;
                 else if (ph < h)
                     // 插入节点需要插入到当前节点的右子节点 或者继续在右子树上查找
                     dir = 1;
                 // 走到这里, 说明当前插入节点的hash与当前节点的hash一致
                 // comparableClassFor: 判断k是否Comparable接口的实现
                 // compareComparables: 通过Comparable接口的compareTo方法判断大小
                 // 如果(节点的Key的Class为null, 且不是Comparable接口的实现), 或通过compareTo比较为0, 即无法通过Comparable相关方法来比较, 在这里做最终排序, 最终拿到的dir一定不是0, 是-1或1
                 else if ((kc == null &&
                           (kc = comparableClassFor(k)) == null) ||
                          (dir = compareComparables(kc, k, pk)) == 0)
                     dir = tieBreakOrder(k, pk);
                 // xp表示插入节点的父节点
                 TreeNode<K,V> xp = p;
                 
                 // 根据dir的值获取p的左子节点或者右子节点, 如果不为null, 则继续向下搜索
                 // 如果为null, 则当前p即为插入节点的父节点
                 if ((p = (dir <= 0) ? p.left : p.right) == null) {
                     // 设置插入节点的父节点为当前节点
                     x.parent = xp;
                     // 小于p节点, 需要插入到p节点的左子节点
                     if (dir <= 0)
                         xp.left = x;
                     else
                         // 大于p节点, 需要插入到p节点的右子节点
                         xp.right = x;
                     // 重新平衡红黑树
                     r = balanceInsertion(r, x);
                     break;
                 }
             }
         }
     }
     // 将r节点赋值给TreeBin对象的root引用
     this.root = r;
     // 进行递归不变检验
     assert checkInvariants(root);
 }

putTreeVal()-将节点插入到红黑树中

 final TreeNode<K,V> putTreeVal(int h, K k, V v) {
     Class<?> kc = null;
     boolean searched = false;
     // 从红黑树根节点开始遍历, p表示当前遍历到的节点
     for (TreeNode<K,V> p = root;;) {
         // dir的值为-1或1, -1表示插入节点的hash值大于当前p节点的hash; 1表示插入节点的hash值小于当前p节点的hash
         // ph: p节点的hash  pk: p节点的key
         int dir, ph; K pk;
         // 如果根节点为null, 则插入的节点为根节点
         if (p == null) {
             // 新建红黑树节点并设置为根节点
             first = root = new TreeNode<K,V>(h, k, v, null, null);
             // 退出循环
             break;
         }
         // 比较插入节点和当前遍历到的节点hash大小
         else if ((ph = p.hash) > h)
             // 插入节点的hash 小于 当前遍历节点, dir为-1
             dir = -1;
         else if (ph < h)
             dir = 1;
         // 走到这里说明hash值相等
         else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
             // 如果key相等, 即为更新, 返回当前遍历的节点
             return p;
         // 如果(节点的Key的Class为null, 且不是Comparable接口的实现), 或通过compareTo比较为0, 即无法通过Comparable相关方法来比较
         else if ((kc == null &&
                   (kc = comparableClassFor(k)) == null) ||
                  (dir = compareComparables(kc, k, pk)) == 0) {
             // 默认执行一次向下遍历, 先向左遍历, 如果没找到目标节点, 再向右遍历
             if (!searched) {
                 TreeNode<K,V> q, ch;
                 searched = true;
                 if (((ch = p.left) != null &&
                      (q = ch.findTreeNode(h, k, kc)) != null) ||
                     ((ch = p.right) != null &&
                      (q = ch.findTreeNode(h, k, kc)) != null))
                     return q;
             }
             // 做最终排序, 最终拿到的dir一定不是0, 是-1或1
             dir = tieBreakOrder(k, pk);
         }

         // xp为插入节点x的父节点(xparent), 中间遍历, 用于下面给x的父节点赋值
         TreeNode<K,V> xp = p;
         // 根据dir判断向左还是向右遍历, 如果子节点为null, 则子节点即为x的插入位置
         if ((p = (dir <= 0) ? p.left : p.right) == null) {
             TreeNode<K,V> x, f = first;
             // 新建红黑树节点, 并将该节点设置为红黑树链表的头节点
             first = x = new TreeNode<K,V>(h, k, v, f, xp);
             // 如果之前的头节点不为null, 设置之前的头节点的前驱指针为新增节点
             if (f != null)
                 f.prev = x;
             // dir<=0, 设置为左子节点
             if (dir <= 0)
                 xp.left = x;
             // dir>0, 设置为右子节点
             else
                 xp.right = x;
             if (!xp.red)
                 x.red = true;
             else {
                 // 添加写锁, 锁住整棵树
                 lockRoot();
                 try {
                     // 重新平衡红黑树
                     root = balanceInsertion(root, x);
                 } finally {
                     // 解锁
                     unlockRoot();
                 }
             }
             break;
         }
     }
     // 进行递归不变检验
     assert checkInvariants(root);
     return null;
 }

addCount()-增加node节点总数,统计map大小

原理同之前将的LongAdder

 // 增加node总数的addCount方法, 该方法满足条件时会扩容
 // put方法: x: 1, check: table在当前下标中元素个数
 // remove方法: x: -1, check: -1
 private final void addCount(long x, int check) {
     // as: LongAdder.cells
     // b: LongAdder.baseCount
     // s: table数组中元素的数量
     CounterCell[] as; long b, s;
     // 条件1: true->表示cells已经初始化了, 当前线程应该去通过hash值查找合适的cells去累加数据
     //       false->表示当前线程应该将数据累加到base
     // 条件2: false->表示写base成功, 数据累加到base中, 当前竞争不激烈, 不需要创建cells
     //       true->表示写base失败, 与其他线程在base上发生竞争, 当前线程应该尝试去创建cells
     if ((as = counterCells) != null ||
         !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
         // 进入该if的情况
         // 1. 条件1为true, 表示cells已经初始化, 需要查找合适的cells
         // 2. 条件2为true, 表示写base失败, 当前线程尝试去创建cells

         // a: 表示当前线程hash查找到的cell; v: 表示当前线程写cell是的期望值; m: 表示当前cells数组的长度
         CounterCell a; long v; int m;
         // true: 未发生锁竞争; false: 发生锁竞争
         boolean uncontended = true;
         // 条件1: as == null || (m = as.length - 1) < 0
         // true->表示cells未初始化, 当前线程是通过写base失败进来的, 需要调用fullAddCount去扩容或重试
         // 条件2: (a = as[ThreadLocalRandom.getProbe() & m]) == null, 前置条件cells已经初始化了
         // true->表示当前线程命中的cell为空, 需要当前线程进入fullAddCount去初始化cell
         // 条件3: !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
         // false->表示当前线程通过CAS更新当前命中的cell成功
         // true->表示当前线程通过CAS更新失败, 需要进入fullAddCount进行扩容
         if (as == null || (m = as.length - 1) < 0 ||
             (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
             !(uncontended =
               U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
             fullAddCount(x, uncontended);
             // 不再参与扩容逻辑, 直接返回
             return;
         }
         if (check <= 1)
             // table在当前下标中元素个数 < 1, 不需要扩容
             return;
         // 获取当前table元素个数, 这是一个期望值
         s = sumCount();
     }
     // ******************  判断扩容  ******************
     // 前置条件, 是put操作调用的addCount
     if (check >= 0) {
         // tab: 当前table数组; nt: nextTable; n: table数组长度; sc: sizeCtl的临时值
         Node<K,V>[] tab, nt; int n, sc;
         // 条件1: s >= (long)(sc = sizeCtl)
         // true-> 1.当前sizeCtl为一个负数, 表示正在扩容中. -1: 当前table正在初始化; 其他负数: 表示当前table数组正在进行扩容, 高16位表示扩容的标识戳, 低16位表示1+nThread, 当前参与并发扩容的线程数量
         //        2.当前sizeCtl为一个正数, 表示扩容阈值
         // false-> 表示当前table尚未达到扩容条件
         while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                (n = tab.length) < MAXIMUM_CAPACITY) {
             // 获取扩容批次唯一标识戳
             int rs = resizeStamp(n);
             // 当前table正在扩容, 当前线程应该协助table扩容
             if (sc < 0) {
                 // 条件1: (sc >>> RESIZE_STAMP_SHIFT) != rs
                 // true-> 当前线程获取到的扩容标识戳非本批次扩容
                 // false-> 当前线程获取到的扩容表示戳是本批次扩容
                 // 条件4: (nt = nextTable) == null
                 // true-> 表示扩容结束
                 // false-> 扩容进行中
                 // 条件5: transferIndex <= 0
                 // true-> 没有扩容步长, 区间任务已分配完
                 // false-> 还有区间任务
                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                     sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                     transferIndex <= 0)
                     break;
                 // 前置条件: 当前table正在扩容, 当前线程有机会参与扩容
                 // true-> 当前线程成功过参与到扩容任务中, 并且将sc低16位加1, 表示多一个线程参与工作
                 // false-> 1. 当前很多线程尝试修改, 当前线程未修改成功
                 //         2. 已经参与扩容任务的线程修改了sizectl
                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                     transfer(tab, nt);
             }
             // 条件成立, 说明当前线程是触发扩容的第一个线程, 在transfer中做一些准备工作
             else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                          (rs << RESIZE_STAMP_SHIFT) + 2))
                 transfer(tab, null);
             // 计算总node数, 用于下次while循环
             s = sumCount();
         }
     }
 }

get方法

 public V get(Object key) {
     Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
     // 进行扰动运算,获取新的hashCode
     int h = spread(key.hashCode());
     // 如果table数组不为空, 长度不为空, 并且可以获取table下标的头节点不为空
     if ((tab = table) != null && (n = tab.length) > 0 &&
         (e = tabAt(tab, (n - 1) & h)) != null) {
         // 如果hash值相等, key值相等, 该头节点即为要找的node, 返回
         if ((eh = e.hash) == h) {
             if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                 return e.val;
         }
         // 如果头节点的hash值<0, 分为两种情况
         // -1为FWD, 说明当前table正在扩容, 调用FWD的find方法
         // -2为TreeBin, 调用TreeBin的find方法
         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;
 }

查看find方法
在这里插入图片描述

find()-ForwardingNode的查找方法

 Node<K,V> find(int h, Object k) {   
     outer: for (Node<K,V>[] tab = nextTable;;) {
         Node<K,V> e; int n;
         // n为nextTable数组的长度
         // e为在nextTable中重新定位hash对应的头节点
         if (k == null || tab == null || (n = tab.length) == 0 ||
             (e = tabAt(tab, (n - 1) & h)) == null)
             return null;
         for (;;) {
             // e节点类型: node类型, TreeBin类型, ForwardingNode类型
             int eh; K ek;
             // node类型的处理
             if ((eh = e.hash) == h &&
                 ((ek = e.key) == k || (ek != null && k.equals(ek))))
                 return e;
             // eh<0分两种情况, TreeBin类型, ForwardingNode类型
             if (eh < 0) {
                 // ForwardingNode类型的处理, 调用ForwardingNode的find方法, 即自身方法
                 if (e instanceof ForwardingNode) {
                     tab = ((ForwardingNode<K,V>)e).nextTable;
                     continue outer;
                 }
                 else
                     // TreeBin类型的处理, 调用红黑树的find方法
                     return e.find(h, k);
             }
             // 继续下次循环
             if ((e = e.next) == null)
                 return null;
         }
     }
 }

在正在扩容中的临时表nextTable中查找

find()-TreeBin的查找方法

 final Node<K,V> find(int h, Object k) {
     if (k != null) {
         // 遍历红黑树链表, e为当前遍历到的节点
         for (Node<K,V> e = first; e != null; ) {
             // s: lock的临时状态  ek: 当前节点e的key
             int s; K ek;
             // WAITER|WRITER, 0010 | 0001 = 0011
             // true-> 当前TreeBin有等待者线程或者写操作线程正在加锁
             if (((s = lockState) & (WAITER|WRITER)) != 0) {
                 // 判断当前节点是否为目标节点. 是的话返回
                 if (e.hash == h &&
                     ((ek = e.key) == k || (ek != null && k.equals(ek))))
                     return e;
                 // 不是目标节点, 继续下次循环
                 e = e.next;
             }
             // 前置条件: 当前TreeBin没有等待者线程或者写锁
             // 通过CAS添加读锁, true-> 添加读锁成功
             else if (U.compareAndSwapInt(this, LOCKSTATE, s,
                                          s + READER)) {
                 // 添加读锁成功
                 TreeNode<K,V> r, p;
                 try {
                     p = ((r = root) == null ? null :
                          r.findTreeNode(h, k, null));
                 } finally {
                     Thread w;
                     // U.getAndAddInt(this, LOCKSTATE, -READER) == (READER|WAITER)
                     // 1. 当前线程查询红黑树结束, 释放当前线程的读锁, 就是将lockstate - 4 
                     // READER|WAITER: 0100 | 0010 = 0110, 如果lockState为0110, 表示当前只有一个线程在读, 且有一个线程在等待
                     // 当前读线程为TreeBin中的最后一个读线程
                     // waiter != null, 说明有一个写线程在等待读操作完毕
                     if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
                         (READER|WAITER) && (w = waiter) != null)
                         // 唤醒写线程
                         LockSupport.unpark(w);
                 }
                 return p;
             }
         }
     }
     return null;
 }

remove方法

/**
     * Implementation for the four public remove/replace methods:
     * Replaces node value with v, conditional upon match of cv if
     * non-null.  If resulting value is null, delete.
     */
    final V replaceNode(Object key, V value, Object cv) {
        int hash = spread(key.hashCode());
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0 ||
                (f = tabAt(tab, i = (n - 1) & hash)) == null)
                break;
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                boolean validated = false;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            validated = true;
                            for (Node<K,V> e = f, pred = null;;) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    V ev = e.val;
                                    if (cv == null || cv == ev ||
                                        (ev != null && cv.equals(ev))) {
                                        oldVal = ev;
                                        if (value != null)
                                            e.val = value;
                                        else if (pred != null)
                                            pred.next = e.next;
                                        else
                                            setTabAt(tab, i, e.next);
                                    }
                                    break;
                                }
                                pred = e;
                                if ((e = e.next) == null)
                                    break;
                            }
                        }
                        else if (f instanceof TreeBin) {
                            validated = true;
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> r, p;
                            if ((r = t.root) != null &&
                                (p = r.findTreeNode(hash, key, null)) != null) {
                                V pv = p.val;
                                if (cv == null || cv == pv ||
                                    (pv != null && cv.equals(pv))) {
                                    oldVal = pv;
                                    if (value != null)
                                        p.val = value;
                                    else if (t.removeTreeNode(p))
                                        setTabAt(tab, i, untreeify(t.first));
                                }
                            }
                        }
                    }
                }
                if (validated) {
                    if (oldVal != null) {
                        if (value == null)
                            addCount(-1L, -1);
                        return oldVal;
                    }
                    break;
                }
            }
        }
        return null;
    }

整体逻辑和hashmap的逻辑差不多,链表删除或者树删除,如果正在扩容那么helpTransfer,等待扩容完成再删除,但是map并没有缩容的方法,阔容之后,即使删除元素,容量也不会减少了

为什么hashmap中允许key或者value为null?而concurrenrtHashMap不允许key或者value为null

map.get(key)的时候,如果返回了null,那么这个null,有两重含义:
这个key从没在map中映射过;
这个key的value在设置的时候就是null
在map中,调用map.get(key)方法得到的值是null,那你无法判断这个key是在map里面没有映射过,还是这个key本身设置就null。这种情况下,在非并发安全的map中,可以通过map.contains(key)的方法来判断。但是在考虑并发安全的map中,两次调用的过程中,这个值是很有可能被改变的。
注意HashMap的key和value都可以为null。

总结

1、将当前key的hash值进行扰动运算,得出新的hash值
2、判断当前table是否初始化,未初始化则进行初始化
3、根据hash值找出数组下标,当前下标处为没有节点数据,则新增节点即可
4、对于写操作。如果当前table数组正在扩容,则帮助扩容
5.1、下标处有节点,且数组未在扩容,则锁定头节点,判断头节点的类型,如果为链表节点,遍历链表,找到了目标节点,则更新,未找到则新增;最后判断节点个数是否超过8,超过且数组长度超过64则将链表转化为红黑树。
更新第8个节点,新增第9个节点才会开始转换
5.2、如果头节点类型为红黑树节点,进行红黑树的节点插入
6、查找操作是无锁的,也不会协助扩容,如果是ForwardingNode,那么读取nextTable对应的槽位

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值