参考文章：

ConcurrentHashMap

由ConcurrentHashMap的结构图可以看出，Node<K,V>[] table是主表（hash桶），是所有链表和树的根节点集合。

ConcurrentHashMap的get，clear，iterator 都是弱一致性的。比如当前线程iterator迭代遍历过程中，其他线程可以更改ConcurrentHashMap。当前线程不会失败可以继续遍历。但是被修改的值可能会体现在本次遍历中，也可能本次遍历仍是旧值。get同理。

 

图 1 

图 2

重要变量 

/** * races. Updated via CAS. * 记录容器的容量大小，通过CAS更新 */private transient volatile long baseCount;/** * 这个sizeCtl是volatile的，那么他是线程可见的，一个思考:它是所有修改都在CAS中进行，但是sizeCtl为什么不设计成LongAdder(jdk8出现的)类型呢？ * 或者设计成AtomicLong(在高并发的情况下比LongAdder低效)，这样就能减少自己操作CAS了。 * * 来看下注释，当sizeCtl小于0说明有多个线程正则等待扩容结果，参考transfer函数 *默认为0，用来控制table的初始化和扩容操作-1 代表table正在初始化 -N 表示有N-1个线程正在进行扩容操作 其余情况： 1、如果table未初始化，表示table需要初始化的大小。 2、如果table初始化完成，表示table的容量，默认是table大小的0.75倍，居然用这个公式算0.75（n - (n >>> 2)） */private transient volatile int sizeCtl;/** *  自旋锁 （锁定通过 CAS） 在调整大小和/或创建 CounterCells 时使用。 在CounterCell类更新value中会使用，功能类似显示锁和内置锁，性能更好 *  在Striped64类也有应用 */private transient volatile int cellsBusy;//默认为null，扩容时新生成的数组，其大小为原数组的两倍private transient volatile Node
    
     [] nextTable;
    

 

问题：负载因子loadFactor会影响HashMap性能

首先回忆HashMap的数据结构，我们都知道有序数组存储数据，对数据的索引效率都很高，但是插入和删除就会有性能瓶颈（回忆ArrayList），链表存储数据，要一次比较元素来检索出数据，所以索引效率低，但是插入和删除效率高（回忆LinkedList），两者取长补短就产生了哈希散列这种存储方式，也就是HashMap的存储逻辑.

而负载因子表示一个散列表的空间的使用程度，有这样一个公式：initailCapacity*loadFactor=HashMap的容量。（initailCapacity为构造器参数）

所以负载因子越大则散列表的装填程度越高，也就是能容纳更多的元素，元素多了，链表大了，所以此时索引效率就会降低。

反之，负载因子越小则链表中的数据量就越稀疏，此时会对空间造成烂费，但是此时索引效率高。

问题：HashMap 既然有hash进行排位还需要equals()

从源码中可以看到HashMap.Node中保存了节点KEY的hash值，通过KEY.hash值方便快速定位节点。但是还是最终调用了KEY.equals()来判断节点KEY是否相等。其原因是java中两个对象equals，则hashCode必然相等，反之不是。

问题：扩容时是乘以2

个人理解是，为了让原Table中每个槽(桶)都能有对应的扩容位置。

例如：原table[0-15]长度16，扩容后nexttable[0-31]长度32。原table[i]在扩容后，将一部分自身节点放入nexttable[i+16]位置上。

 

转移节点形态

当有resize扩容操作在进行中的时候，已经转移到新数组的bin节点在原来的位置被放进一个ForwardingNode结点。这保证了有resize操作正在进行中的时候，不会阻塞对ConcurrentHashMap的读操作。例如，如果有一个调用get操作的线程，它的key的hash码映射到了一个ForwardingNode，那么它会从这个ForwadingNode结点中的nextTable字段找到新数组的引用，然后再找到新数组nextTable的对应bin节点。ForwadingNode表示当前槽已经成功转移到新table，但是整个table还没有全部转移成功。

另外，数组table除了可以存放Node, TreeBin和ForwadingNode之外，还可以存放一种特殊类型的结点ReservationNode，它主要是用来帮助实现Java 8的新增API ConcurrentHashMap.comptuteIfAbsent的。

图 3

Node节点

val和next引用变量都是volatile,保证了高可见性

static class Node
    
      implements Map.Entry
     
       {        final int hash; //key的hash值        final K key;        volatile V val;        volatile Node
      
        next;        Node(int hash, K key, V val, Node
       
         next) {            this.hash = hash;            this.key = key;            this.val = val;            this.next = next;        }        public final K getKey()       { return key; }        public final V getValue()     { return val; }        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }        public final String toString(){ return key + "=" + val; }        public final V setValue(V value) {            throw new UnsupportedOperationException();        }        public final boolean equals(Object o) {            Object k, v, u; Map.Entry
         e;            return ((o instanceof Map.Entry) &&                    (k = (e = (Map.Entry
        )o).getKey()) != null &&                    (v = e.getValue()) != null &&                    (k == key || k.equals(key)) &&                    (v == (u = val) || v.equals(u)));        }        /**         * Virtualized support for map.get(); overridden in subclasses.         */        Node
        
          find(int h, Object k) {            Node
         
           e = this; if (k != null) { do { K ek; if (e.hash == h && ((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; } while ((e = e.next) != null); } return null; } }
         
        
       
      
     
    

putVal方法

通过CAS+volatile+synchronized(table[i]) 实现线程安全。

put操作过程要注意，只有在执行到break之后才会跳出循环，没有遇到break则会重试。JDK代码的重试功能几乎全部是用死循环来实现的。采用CAS+synchronized实现并发插入或更新操作。

执行思路：

for（取得table变量）（ //下边内容无限循环重试，中间有任何条件失败，不尝试挽救直接重新循环，直到break

1. 如果table==null，CAS初始化table。
2. 如果table对应位置table[i]上是空的（null），那么用CAS赋值来保证线程安全性,若成功break。
3. 如果table[i]这个位置是ForwardingNode(正在扩容)，则当前线程协助执行一部分transfer工作，然后再在新table中重试。
4. 如果table[i]这个位置已有节点且是单链表或红黑树，那么才进行分段锁synchronized(table[i])，如果有hash碰撞更新原节点的val，否则加入链表尾部或红黑树，若成功break  。

）

最后判断是否需要转红黑树

源码：

--onlyIfAbsent只有不存在时putfinal V putVal(K key, V value, boolean onlyIfAbsent) {        if (key == null || value == null) throw new NullPointerException(); // 键或值为空，抛出异常        // 键的hash值经过计算获得hash值        int hash = spread(key.hashCode());        int binCount = 0;        for (Node
    
     [] tab = table;;) { // 无限自循环 初次循环初始重新取得table            //此table为最外层Node[]，其中各节点为首节点，也是分段锁节点            Node
     
       f; int n, i, fh;            if (tab == null || (n = tab.length) == 0) //table为空或者表的长度为0                // CAS table初始化                tab = initTable();            //i= (n - 1) & hash 相当于 (hash mod tab.length-1) 通过取模找到hash对应根节点位置            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { //CAS tabAt()找到table中i位置根节点                // table不为空并且table的长度大于0，并且新Node计算对应位置==null                // CAS原子比较并且交换值，如tab的第i项为空则用新生成的node替换                if (casTabAt(tab, i, null,new Node
      
       (hash, key, value, null))) //CAS                    break; //成功后退出for自旋，否则继续for自旋                              }            else if ((fh = f.hash) == MOVED) // 该根结点的hash值为MOVED(-1)                // 此根节点在扩容的过程中，当前线程协助扩容                tab = helpTransfer(tab, f);            else {                V oldVal = null;               //synchronized锁住了f,因为f是指定特定的tab[i]的，               //所以就锁住了整行链表,这个设计跟分段锁有异曲同工之妙，只是其他读取操作需要用cas来保证                synchronized (f) { //取得当前f的内置锁                    //二次检查  如果当前i位置根节点还是f没变，则继续                    if (tabAt(tab, i) == f) {                         if (fh >= 0) { // f的hash值大于0（链表）                            // binCount赋值为1                            binCount = 1;                            for (Node
       
         e = f;; ++binCount) { // 循环遍历链表  binCount统计链表长度                                K ek;                                if (e.hash == hash &&                                    ((ek = e.key) == key ||                                     (ek != null && key.equals(ek)))) {                                     //hash碰撞，结点的hash值相等并且key也相等，只需更新原节点的val值                                    //保存该结点的原值                                    oldVal = e.val;                                    if (!onlyIfAbsent) // 进行判断 是否为 没有才put                                        // 更新节点的val值                                        e.val = value;                                    // 退出子循环                                    break;                                }                                // 保存当前结点                                Node
        
          pred = e;                                //e = e.next 更新e 为下次子循环准备                                if ((e = e.next) == null) {                                     // 当前结点的下一个结点为空，即为最后一个结点                                    // 新生一个结点并且赋值给next域                                    pred.next = new Node
         
          (hash, key, value, null); // 退出子循环 break; } } } else if (f instanceof TreeBin) { // 结点为红黑树结点类型 Node
          
            p; // binCount赋值为2 binCount = 2; if ((p = ((TreeBin
           
            )f).putTreeVal(hash, key, value)) != null) { // 将hash、key、value放入红黑树 // 保存结点的val oldVal = p.val; if (!onlyIfAbsent) // 判断 // 赋值结点value值 p.val = value; } } } } //synchronized结束 if (binCount != 0) { // binCount不为0 if (binCount >= TREEIFY_THRESHOLD) // 如果binCount大于等于转化为红黑树的阈值 // 进行转化 treeifyBin(tab, i); if (oldVal != null) // 旧值不为空 // 返回旧值 return oldVal; break; } } } // 增加binCount的数量 addCount(1L, binCount); return null; }
           
          
         
        
       
      
     
    

伪代码流程 ：

initTable 初始化 主table

volatile int sizeCtl：-1 代表table正在初始化 ，-N 表示有N-1个线程正在进行扩容操作 

双重检查CAS锁 机制 保证只有第一个通过CAS锁的线程能够创建table

private final Node
    
     [] initTable() {        Node
     
      [] tab; int sc;        while ((tab = table) == null || tab.length == 0) { // 无限循环            if ((sc = sizeCtl) < 0) // sizeCtl小于0，已有线程初始化，则当前线程让出cpu                Thread.yield(); // lost initialization race; just spin            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { // 比较sizeCtl的值与sc是否相等，相等则用-1替换                //这里 CAS SIZECTL=-1 相当于上锁                try {                    /**                         CAS锁通过后二次检查table，这步必须有。否则可能重复创建table                        原因：可能线程2运行到CAS时，放弃CPU时间片                        这时线程1 CAS通过创建table后将CAS锁复原。                        线程2此时取得cpu时间片继续运行，CAS可以通过                        若进入CAS锁后没有二次检查，那么线程2将重复创建table                    */                    if ((tab = table) == null || tab.length == 0) {                         // sc的值是否大于0，若是，则n为sc，否则，n为默认初始容量                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;                        @SuppressWarnings("unchecked")                        // 新生结点数组                        Node
      
       [] nt = (Node
       
        [])new Node
        [n];                        // 赋值给table                        table = tab = nt;                        // sc为n * 3/4                        sc = n - (n >>> 2);                    }                } finally {                    // 设置sizeCtl的值                    sizeCtl = sc;                }                break;            }        }        // 返回table表        return tab;    }
       
      
     
    

casTabAt更新table中的值

底层使用unsafe实现CAS更新，与AtomicReferenceArray一样

static final 
    
      boolean casTabAt(Node
     
      [] tab, int i,                                        Node
      
        c, Node
       
         v) {        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);    }
       
      
     
    

helpTransfer 协助扩容

此函数用于在扩容时将table表中的结点转移到nextTable中（图3）。如果线程进入到这边说明已经有其他线程正在做扩容操作，这个是一个辅助方法。

final Node
    
     [] helpTransfer(Node
     
      [] tab, Node
      
        f) {        Node
       
        [] nextTab; int sc;        //table表不为空,并且结点类型使ForwardingNode类型，并且结点的nextTable不为空（图 3）        if (tab != null && (f instanceof ForwardingNode) &&(nextTab = ((ForwardingNode
        
         )f).nextTable) != null) {             int rs = resizeStamp(tab.length);            //当前全局nextTable与此节点相同 + 当前全局table与入参tab相同 + 全局sizeCtl<0            while (nextTab == nextTable && table == tab &&(sc = sizeCtl) < 0) {                 //满足条件就循环 直到break                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||                    sc == rs + MAX_RESIZERS || transferIndex <= 0) //                     break;                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) { // 比较并交换                    // 将table的结点转移到nextTab中                    transfer(tab, nextTab);                    break;                }            }            return nextTab;        }        return table;    }
        
       
      
     
    

get方法

无锁化操作，因相关变量都加上了volatile修饰(Node的val和next)，保证了高可见性。所以get操作自身几乎无需考虑线程安全性和变量可见性，只需要注意原子性。这里的原子性指的是，get操作中的被多个线程共享的table变量及节点属性等可能也在被其他线程修改，所以需要一开始就把它们保存到局部变量，然后再使用，这样就不必担心有其他线程修改了。

执行思路：

1. 如果table不为空，且查找key.hash能在table中找到对应根节点，则继续。
2. 如果根节点key的hash完全等于查找key.hash，return 根节点.val。
3. 根节点hash<0，查找ForwadingNode or 红黑树
4. 根节点hash>=0，查找链表

源码：

public V get(Object key) {        Node
    
     [] tab; Node
     
       e, p; int n, eh; K ek;        //e是key.hash对应的table根节点        // 计算key的hash值        int h = spread(key.hashCode());         if ((tab = table) != null && (n = tab.length) > 0 &&(e = tabAt(tab, (n - 1) & h)) != null) {             // 表不为空并且表的长度大于0并且key所在的根节点不为空            if ((eh = e.hash) == h) { // 表中的根节点的hash值与key的hash值相等                // 与根节点key相等                if ((ek = e.key) == key || (ek != null && key.equals(ek)))                     // 返回根节点                    return e.val;            }            else if (eh < 0) // 当前根结点hash值小于0  红黑树/ForwadingNode(扩容中)                return (p = e.find(h, key)) != null ? p.val : null;                /**                     eh==-1 根节点是ForwadingNode，数据迁移中。通过ForwadingNode.find找到nextTable中节点。                    eh==-2 根节点是TreeBin。TreeBin.find遍历红黑树。因为红黑树可能正在平衡调整，所以find中有读写锁控制。                                 */                                          //   eh>=0  链表 根结点hash值大于0的情况            while ((e = e.next) != null) {                 if (e.hash == h &&                    ((ek = e.key) == key || (ek != null && key.equals(ek))))                    return e.val;            }        }        return null;    }
     
    

伪代码流程 ：

 

table 扩容

https://www.jianshu.com/p/2829fe36a8dd

当table的元素数量达到容量阈值，需要对table进行扩容： 

- 构建一个nextTable，大小为table两倍

- 把table的数据复制到nextTable中。 （图3）

在扩容过程中，依然支持并发读写操作。 

该方法的执行逻辑如下：

1. 通过计算 CPU 核心数和 Map 数组的长度得到每个线程（CPU）要帮助处理多少个桶，并且这里每个线程处理都是平均的。默认每个线程处理 16 个桶。因此，如果长度是 16 的时候，扩容的时候只会有一个线程扩容。

2. 初始化临时变量 nextTable。将其在原有基础上扩容两倍。

3. 死循环开始转移。多线程并发转移就是在这个死循环中，根据一个 finishing 变量来判断，该变量为 true 表示扩容结束，否则继续扩容。

   3.1 进入一个 while 循环，分配数组中一个桶的区间给线程，默认是 16. 从大到小进行分配。当拿到分配值后，进行 i-- 递减。这个 i 就是数组下标。（其中有一个 bound 参数，这个参数指的是该线程此次可以处理的区间的最小下标，超过这个下标，就需要重新领取区间或者结束扩容，还有一个 advance 参数，该参数指的是是否继续递减转移下一个桶，如果为 true，表示可以继续向后推进，反之，说明还没有处理好当前桶，不能推进)

   3.2 出 while 循环，进 if 判断，判断扩容是否结束，如果扩容结束，清空临时变量，更新 table 变量，更新库容阈值。如果没完成，但已经无法领取区间（没了），该线程退出该方法，并将 sizeCtl 减一，表示扩容的线程少一个了。如果减完这个数以后，sizeCtl 回归了初始状态，表示没有线程再扩容了，该方法所有的线程扩容结束了。（这里主要是判断扩容任务是否结束，如果结束了就让线程退出该方法，并更新相关变量）。然后检查所有的桶，防止遗漏。
   3.3 如果没有完成任务，且 i 对应的槽位是空，尝试 CAS 插入占位符，让 putVal 方法的线程感知。
   3.4 如果 i 对应的槽位不是空，且有了占位符，那么该线程跳过这个槽位，处理下一个槽位。
   3.5 如果以上都是不是，说明这个槽位有一个实际的值。开始同步处理这个桶。
   3.6 到这里，都还没有对桶内数据进行转移，只是计算了下标和处理区间，然后一些完成状态判断。同时，如果对应下标内没有数据或已经被占位了，就跳过了。

4. 处理每个桶的行为都是同步的（synchronized ）。防止 putVal 的时候向链表插入数据，也防止其他线程再来调整此桶。整个Map扩容过程支持并发写入，但是当要写入的桶(槽)正在扩容调整时，是阻塞写入的。

   4.1 如果这个桶是链表，那么就将这个链表根据 length 取余拆成两份，取余结果是 0 的放在新表的低位，取余结果是 1 放在新表的高位。
   4.2 如果这个桶是红黑数，那么也拆成 2 份，方式和链表的方式一样，然后，判断拆分过的树的节点数量，如果数量小于等于 6，改造成链表。反之，继续使用红黑树结构。
   4.3 到这里，就完成了一个桶从旧表转移到新表的过程。

好，以上，就是 transfer 方法的总体逻辑。还是挺复杂的。再进行精简，分成 3 步骤：

1. 计算每个线程可以处理的桶区间。默认 16.
2. 初始化临时变量 nextTable，扩容 2 倍。
3. 死循环，计算下标。完成总体判断。
4. 1 如果桶内有数据，同步转移数据。通常会像链表拆成 2 份。

/** * Moves and/or copies the nodes in each bin to new table. See * above for explanation. *  * transferIndex 表示转移时的下标，初始为扩容前的 length。 *  * 我们假设长度是 32 */private final void transfer(Node
    
     [] tab, Node
     
      [] nextTab) {    int n = tab.length, stride;    // 将 length / 8 然后除以 CPU核心数。如果得到的结果小于 16，那么就使用 16。    // 这里的目的是让每个 CPU 处理的桶一样多，避免出现转移任务不均匀的现象，如果桶较少的话，默认一个 CPU（一个线程）处理 16 个桶    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)        stride = MIN_TRANSFER_STRIDE; // subdivide range 细分范围 stridea：TODO    // 新的 table 尚未初始化    if (nextTab == null) {            // initiating        try {            // 扩容  2 倍            Node
      
       [] nt = (Node
       
        [])new Node
        [n << 1];            // 更新            nextTab = nt;        } catch (Throwable ex) {      // try to cope with OOME            // 扩容失败， sizeCtl 使用 int 最大值。            sizeCtl = Integer.MAX_VALUE;            return;// 结束        }        // 更新成员变量        nextTable = nextTab;        // 更新转移下标，就是 老的 tab 的 length        transferIndex = n;    }    // 新 tab 的 length    int nextn = nextTab.length;    // 创建一个 fwd 节点，用于占位。当别的线程发现这个槽位中是 fwd 类型的节点，则跳过这个节点。    ForwardingNode
        
          fwd = new ForwardingNode
         
          (nextTab); // 首次推进为 true，如果等于 true，说明需要再次推进一个下标（i--），反之，如果是 false，那么就不能推进下标，需要将当前的下标处理完毕才能继续推进 boolean advance = true; // 完成状态，如果是 true，就结束此方法。 boolean finishing = false; // to ensure sweep before committing nextTab // 死循环,通过for自循环处理每个槽位中的链表元素，默认advace为真，通过CAS设置transferIndex属性值，并初始化i和bound值，i指当前线程处理的槽位序号，bound指需要处理的槽位边界，先处理槽位15的节点； for (int i = 0, bound = 0;;) { Node
          
            f; int fh; // 如果当前线程可以向后推进；这个循环就是控制 i 递减。同时，每个线程都会进入这里取得自己需要转移的桶的区间 while (advance) {//线程获取任务 int nextIndex, nextBound; // 对 i 减一，判断是否大于等于 bound （正常情况下，如果大于 bound 不成立，说明该线程上次领取的任务已经完成了。那么，需要在下面继续领取任务） // 如果对 i 减一大于等于 bound（还需要继续做任务），或者完成了，修改推进状态为 false，不能推进了。任务成功后修改推进状态为 true。 // 通常，第一次进入循环，i-- 这个判断会无法通过，从而走下面的 nextIndex 赋值操作（获取最新的转移下标）。其余情况都是：如果可以推进，将 i 减一，然后修改成不可推进。如果 i 对应的桶处理成功了，改成可以推进。 if (--i >= bound || finishing) advance = false;// 这里设置 false，是为了防止在没有成功处理一个桶的情况下却进行了推进 // 这里的目的是：1. 当一个线程进入时，会选取最新的转移下标。2. 当一个线程处理完自己的区间时，如果还有剩余区间的没有别的线程处理。再次获取区间。 else if ((nextIndex = transferIndex) <= 0) { // 如果小于等于0，说明没有区间了 ，i 改成 -1，推进状态变成 false，不再推进，表示，扩容结束了，当前线程可以退出了 // 这个 -1 会在下面的 if 块里判断，从而进入完成状态判断 i = -1; advance = false;// 这里设置 false，是为了防止在没有成功处理一个桶的情况下却进行了推进 }// CAS 修改 transferIndex，即 length - 区间值，留下剩余的区间值供后面的线程使用 else if (U.compareAndSwapInt (this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) { //当前线程取得任务，i指当前线程处理的槽位序号，bound指需要处理的槽位边界 bound = nextBound;// 这个值就是当前线程可以处理的最小当前区间最小下标 i = nextIndex - 1; // 初次对i 赋值，这个就是当前线程可以处理的当前区间的最大下标 advance = false; // 这里设置 false，是为了防止在没有成功处理一个桶的情况下却进行了推进，这样对导致漏掉某个桶。下面的 if (tabAt(tab, i) == f) 判断会出现这样的情况。 } }// 如果 i 小于0 （不在 tab 下标内，按照上面的判断，领取最后一段区间的线程扩容结束） // 如果 i >= tab.length(不知道为什么这么判断) // 如果 i + tab.length >= nextTable.length （不知道为什么这么判断） if (i < 0 || i >= n || i + n >= nextn) { int sc; if (finishing) { // 如果完成了扩容 nextTable = null;// 删除成员变量 table = nextTab;// 更新 table sizeCtl = (n << 1) - (n >>> 1); // 更新阈值 return;// 结束方法。 }// 如果没完成 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {// 尝试将 sc -1. 表示这个线程结束帮助扩容了，将 sc 的低 16 位减一。 if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)// 如果 sc - 2 不等于标识符左移 16 位。如果他们相等了，说明没有线程在帮助他们扩容了。也就是说，扩容结束了。 return;// 不相等，说明没结束，当前线程结束方法。 finishing = advance = true;// 如果相等，扩容结束了，更新 finising 变量 i = n; // 再次循环检查一下整张表 } } else if ((f = tabAt(tab, i)) == null) // 获取老 tab[i]下标位置的变量，如果是 null，就使用 fwd 占位。用于告诉其它线程该槽位已经处理过了； advance = casTabAt(tab, i, null, fwd);// 如果成功写入 fwd 占位，再次推进一个下标 else if ((fh = f.hash) == MOVED)// 如果不是 null 且 hash 值是 MOVED。 advance = true; // already processed //[i]槽 说明别的线程已经处理过了，再次推进一个下标 else {// 到这里，说明这个位置有实际值了，且不是占位符。对这个节点上锁。为什么上锁，防止 putVal 的时候向链表插入数据 synchronized (f) { // 判断 i 下标处的桶节点是否和 f 相同 if (tabAt(tab, i) == f) { Node
           
             ln, hn;// low, height 高位桶，低位桶 // 如果 f 的 hash 值大于 0 。TreeBin 的 hash 是 -2 if (fh >= 0) { // 对老长度进行与运算（第一个操作数的的第n位于第二个操作数的第n位如果都是1，那么结果的第n为也为1，否则为0） // 由于 Map 的长度都是 2 的次方（000001000 这类的数字），那么取于 length 只有 2 种结果，一种是 0，一种是1 // 如果是结果是0 ，Doug Lea 将其放在低位，反之放在高位，目的是将链表重新 hash，放到对应的位置上，让新的取于算法能够击中他。 int runBit = fh & n; Node
            
              lastRun = f; // 尾节点，且和头节点的 hash 值取于不相等 // 遍历这个桶 for (Node
             
               p = f.next; p != null; p = p.next) { // 取于桶中每个节点的 hash 值 int b = p.hash & n; // 如果节点的 hash 值和首节点的 hash 值取于结果不同 if (b != runBit) { runBit = b; // 更新 runBit，用于下面判断 lastRun 该赋值给 ln 还是 hn。 lastRun = p; // 这个 lastRun 保证后面的节点与自己的取于值相同，避免后面没有必要的循环 } } if (runBit == 0) {// 如果最后更新的 runBit 是 0 ，设置低位节点 ln = lastRun; hn = null; } else { hn = lastRun; // 如果最后更新的 runBit 是 1， 设置高位节点 ln = null; }// 再次循环，生成两个链表，lastRun 作为停止条件，这样就是避免无谓的循环（lastRun 后面都是相同的取于结果） for (Node
              
                p = f; p != lastRun; p = p.next) { int ph = p.hash; K pk = p.key; V pv = p.val; // 如果与运算结果是 0，那么就还在低位 if ((ph & n) == 0) // 如果是0 ，那么创建低位节点 ln = new Node
               
                (ph, pk, pv, ln); else // 1 则创建高位 hn = new Node
                
                 (ph, pk, pv, hn); } // 其实这里类似 hashMap // 设置低位链表放在新链表的 i setTabAt(nextTab, i, ln); // 设置高位链表，在原有长度上加 n setTabAt(nextTab, i + n, hn); // 将旧的链表设置成占位符，用于告诉其它线程该槽位已经处理过了 setTabAt(tab, i, fwd); // 继续向后推进 advance = true; }// 如果是红黑树 else if (f instanceof TreeBin) { TreeBin
                 
                   t = (TreeBin
                  
                   )f; TreeNode
                   
                     lo = null, loTail = null; TreeNode
                    
                      hi = null, hiTail = null; int lc = 0, hc = 0; // 遍历 for (Node
                     
                       e = t.first; e != null; e = e.next) { int h = e.hash; TreeNode
                      
                        p = new TreeNode
                       
                         (h, e.key, e.val, null, null); // 和链表相同的判断，与运算 == 0 的放在低位 if ((h & n) == 0) { if ((p.prev = loTail) == null) lo = p; else loTail.next = p; loTail = p; ++lc; } // 不是 0 的放在高位 else { if ((p.prev = hiTail) == null) hi = p; else hiTail.next = p; hiTail = p; ++hc; } } // 如果树的节点数小于等于 6，那么转成链表，反之，创建一个新的树 ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : (hc != 0) ? new TreeBin
                        
                         (lo) : t; hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : (lc != 0) ? new TreeBin
                         
                          (hi) : t; // 低位树 setTabAt(nextTab, i, ln); // 高位数 setTabAt(nextTab, i + n, hn); // 旧的设置成占位符 用于告诉其它线程该槽位已经处理过了 setTabAt(tab, i, fwd); // 继续向后推进 advance = true; } } } } }}
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     
    

然后，说说精华的部分。

1. Cmap 支持并发扩容，实现方式是，将表拆分，让每个线程处理自己的区间。如下图：

假设总长度是 64 ，每个线程可以分到 16 个桶，各自处理，不会互相影响。一个桶只会被一个线程扩容。

1. 而每个线程在处理自己桶中的数据的时候，是下图这样的：

 扩容前的状态。当对 4 号桶或者 10 号桶进行转移的时候，会将链表拆成两份，规则是根据节点的 hash 值取于 length，如果结果是 0，放在低位，否则放在高位。

因此，10 号桶的数据，黑色节点会放在新表的 10 号位置（低位10 号），白色节点会放在新桶的 26 号位置（高位10 号）。

因为扩容为原来的两倍，老table为0-15.。所以新table为[0-15 ]+[16-31]。26号位置是后半段的第10号位置。

下图是循环处理桶中数据的逻辑：

 

处理完之后，新桶的数据是这样的：