【Java多线程】ConcurrentHashMap 的实现原理（二十）

一、概述

　　本章使用的是JDK8。

　　阅读本章请先了解HashMap的实现原理【Java】HashMap 的实现原理

1.1 ConcurrentHashMap跟HashMap，HashTable的对比

1. HashMap不是线程安全：

　　在并发环境下，可能会形成环状链表（扩容时可能造成，具体原因自行百度google或查看源码分析），导致get操作时，cpu空转，所以，在并发环境中使用HashMap是非常危险的，实现原理参考：【Java】HashMap 的实现原理

2. HashTable是线程安全的：

　　HashTable和HashMap的实现原理几乎一样，

　　差别：

• 1.HashTable不允许key和value为null；
• 2.HashTable是线程安全的。

　　HashTable线程安全的策略实现代价却比较大，get/put所有相关操作都是synchronized的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞

3. ConcurrentHashMap是线程安全的：

　　直接采用transient volatile HashEntry<K,V>[] table保存数据，采用table数组元素作为锁，从而实现了对每一行数据进行加锁，并发控制使用Synchronized和CAS来操作，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这 样便可以有效地提高并发效率。这就是ConcurrentHashMap所采用的"分段锁"思想

二、结构图

　　

　　由图可以看出，ConcurrentHashMap的结构是：数组 + 链表 + 红黑树

三、属性

// node数组最大容量：2^30=1073741824
private static final int MAXIMUM_CAPACITY = 1 << 30;

// 默认初始值，必须是2的幕数
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;

// 链表转红黑树阀值,> 8 链表转换为红黑树
static final int TREEIFY_THRESHOLD = 8;

// 链表转红黑树时，最小容量阀值, >= 64 链表转换为红黑树
static final int MIN_TREEIFY_CAPACITY = 64;

// 树转链表阀值，小于等于6（tranfer时，lc、hc=0两个计数器分别++记录原bin、新binTreeNode数量，<=UNTREEIFY_THRESHOLD 则untreeify(lo)）
static final int UNTREEIFY_THRESHOLD = 6;

// 最小转移数组步长
private static final int MIN_TRANSFER_STRIDE = 16;

// 可以帮助调整大小的最大线程数，计算用到
private static int RESIZE_STAMP_BITS = 16;

// 2^15-1，help resize的最大线程数
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;

// 32-16=16，sizeCtl中记录size大小的偏移量
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;

// forwarding nodes的hash值
static final int MOVED     = -1;
// 树根节点的hash值
static final int TREEBIN   = -2;
// ReservationNode的hash值
static final int RESERVED  = -3;

// 可用处理器数量
static final int NCPU = Runtime.getRuntime().availableProcessors();

// 存放node的数组
transient volatile Node<K,V>[] table;

// 控制标识符，用来控制table的初始化和扩容的操作，不同的值有不同的含义
// 当为0时：代表当时的table还没有被初始化
// 当为负数时：-1代表正在初始化
// 小于-1时：实际值为resizeStamp(n) <<RESIZE_STAMP_SHIFT+2, 表明table正在扩容
// 当为正数时：未初始化，代表初始化大小，初始化完成后, 代表下一次扩容时的阀值, 默认为0.75*n
private transient volatile int sizeCtl;

// table容量从n扩到2n时, 是从索引n->1的元素开始迁移, transferIndex代表当前已经迁移的元素下标
private transient volatile int transferIndex;

// 基础计算器值
private transient volatile long baseCount;

// 计数器数组
private transient volatile CounterCell[] counterCells;

　　下面是 Node 类的定义，它是 HashMap 中的一个静态内部类，哈希表中的每一个 节点都是 Node 类型。我们可以看到，Node 类中有 4 个属性，其中除了 key 和 value 之外，还有 hash 和 next 两个属性。hash 是用来存储 key 的哈希值的，next 是在构建链表时用来指向后继节点的

static class Node<K,V> implements Map.Entry<K,V> {
    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;  // red-black tree links
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;


    ......
}

　　树箱子节点TreeBin

static final class TreeBin<K,V> extends Node<K,V> {
    TreeNode<K,V> root;
    volatile TreeNode<K,V> first;
    volatile Thread waiter;
    volatile int lockState;
    // values for lockState
    static final int WRITER = 1; // set while holding write lock
    static final int WAITER = 2; // set when waiting for write lock
    static final int READER = 4; // increment value for setting read lock


    ......
}

　　

四、方法

1、构造方法

　　ConcurrentHashMap 提供了五种方式的构造器，但是都为初始化数组，如下：

// 创建一个空的哈希表
public ConcurrentHashMap() {
}

// 创建一个空的哈希表，指定初始容量
public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
               MAXIMUM_CAPACITY :
               tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    this.sizeCtl = cap;
}

// 创建一个新哈希表，将map的元素放入其中
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    this.sizeCtl = DEFAULT_CAPACITY;
    putAll(m);
}

// 创建一个新哈希表，指定初始容量、加载因子;
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, 1);
}

// 创建一个新哈希表，指定初始容量、加载因子、并发级别
public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel)   // Use at least as many bins
        initialCapacity = concurrencyLevel;   // as estimated threads
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    this.sizeCtl = cap;
}

2、put 方法

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

/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    // binCount: i处结点数量,
    // 或者TreeBin或链表结点数, 其它：链表结点数。主要用于每次加入结点后查看是否要由链表转为红黑树
    int binCount = 0;
    //CAS经典写法，不成功无限重试，让再次进行循环进行相应操作
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 除非构造时指定初始化集合，否则默认构造不初始化table，所以需要在添加时元素检查是否需要初始化。
        if (tab == null || (n = tab.length) == 0)
            // 初始化集合　　
            tab = initTable();
        // table[i] 对应桶无元素
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // CAS操作得到对应table中元素
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // table[i]对应桶上节点 hash值 为MOVEN 表示集合正在扩容
        else if ((fh = f.hash) == MOVED)
            // 本线程去帮助集合扩容
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 给 table[i] 对应桶元素加锁，其他线程无法操作此桶中元素
            synchronized (f) {
                // 再次判断是否table[i]被改变
                if (tabAt(tab, i) == f) {
                    // fh >= 0 表明是链表结点类型
                    // 节点hash值是大于等于0的，即spread()方法计算而来，
                    // 扩容时已迁移hash值为 -1
                    // 如果是TreeBin树节点hash值为 -2
                    // ReservationNode的hash值 -3 
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 找到相等key值的节点
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                // onlyIfAbsent表示是新元素才加入，旧值不替换，默认为fase。
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            // 链表最后，未找到节点，加入链表尾
                            // jdk1.8版本是把新结点加入链表尾部，next由volatile修饰
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    // 红黑树结点类型
                    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;
                        }
                    }
                }
            }
            if (binCount != 0) {
                // 判断binCount是否大于等于8，即链表上节点树大于8，为大于等于9
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 集合大大小+1，即size+1
    addCount(1L, binCount);
    return null;
}

　　put 方法比较复杂，实现步骤大致如下:

　　1、先通过 hash 值计算出 key 映射到哪个桶。

　　2、如果桶上没有碰撞冲突，则直接CAS操作插入。

　　3、如果出现碰撞冲突了，则需要处理冲突:

　　　　(1) 如果该桶hash 值表示数组正在扩容，本线程去帮助集合扩容，扩容完成然后在重新插入

　　　　(2) 否则去获取锁，synchronized (table[i])，进入插入操作，然后解锁

　　　　　　- 如果该桶时采用传统的链式，从链表尾插入链表。如果链的长度到达临界值，则把链转变为红黑树

　　　　　　- 如果时使用红黑树处理冲突，则调用红黑树的方法插入。

　　4、如果桶中存在重复的键，则为该键替换新值。

　　5、添加记数值，如果集合大小大于等于阈值，则进行扩容。

3、initTable() 初始化表方法

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // 正在初始化时将sizeCtl设为-1
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 创建节点数组
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    // 扩容阈值为新容量的0.75倍
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

4、addCount() 方法

// x 新添加的元素数量
// check 往往传入某个位置哈希桶的链表或者红黑树数量
// x为1表示添加一个新元素，-1表示删除
// x = 1，check = 0
// 添加计算数量
private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;

    // 程序第一次counterCells必然为空 (as = counterCells) != null 为false
    // !U.compareAndSwapLong(this...) cas 方式增加baseCount数量
    // 在没有竞争的情况下修改完baseCount返回函数

    // 存在竞争情况，条件满足，进入方法体
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        

        boolean uncontended = true;
        // as 为null 所以直接进入方法体 

        //if 作用1：如果当前as为空证明多线程导致baseCount赋值失败，所以需要初始化一个counterCells数组进行统计
        //if 作用2：如果当前as不为空，且当前线程对应as数组存储的对象不为空，那么直接用实例对象存储的数值加上当前插入的数据累加和即可
        //if 作用3：如果当前as不为空，但是对应线程数组下标实例为空，那么调用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
            fullAddCount(x, uncontended);
            // 返回
            return;
        }
        // 上面if条件不满足，表示已经数值添加到baseCount 和 counterCells 数组中
        // 很少情况check传入小于1，如果传入了那么证明不需要检查扩容，直接返回就好
        if (check <= 1)
            return;
        // sumcount返回当前ConcurrentHashMap数量
        // 即 baseCount 加 counterCells 数组的 数值之和
        s = sumCount();
    }
    // check >= 0进行扩容逻辑
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        // s表示 存储元素数量（表的大小）
        // s >= (long)(sc = sizeCtl)  当前表的存储元素数量必须大于等于阈值
        // (tab = table) != null 数组不为空
        // (n = tab.length) < MAXIMUM_CAPACITY  数组容量当前小于最大扩容上限
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {

            //resizeStamp返回的rs低15位表示当前容量n扩容标识，用于表示是对n的扩容。（在数值不直接表示，而是表示n前面最高位为1前面有多少个0）
            //resizeStamp返回的rs的从低位开始数的第16位一定为1（比如说0000 0000 0000 0000 1000 0000 0000 0000）
            //resizeStamp具体看引用文章[3]
            // 第一次n= 16，rs = 0000 0000 0000 0000 1000 0000 0001 1011
            int rs = resizeStamp(n);
            // 哈希表正在扩容
            if (sc < 0) {
                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);
            }
            // 哈希表未扩容
            // sizeCtl 设置值
            // 第一次扩容设置值 sizeCtl = 1000 0000 0001 1011 0000 0000 0000 0010(二进制)
            // 高15位：容量n扩容标识
            // 低16位：并行扩容线程数+1
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))

                // 转移扩容
                transfer(tab, null);

            // s即 baseCount 加 counterCells 数组的 数值之和
            s = sumCount();
        }
    }
}

　　addCount 方法比较复杂，实现步骤大致如下:

　　1、添加计数值

　　　　(1) 将数值根据线程特有值，添加到counterCells 计数数组 对应的值中

　　　　(2) 如果失败或冲突，调用fullAddCount() 添加计数

　　2、进行扩容

　　　　(1) 判断是否hash表正在扩容，如果是帮组哈希表扩容

　　　　(2) 如果不是，去调用transfer() 方法扩容

　　关于resizeStamp()：可以百度，或参考 https://blog.csdn.net/tp7309/article/details/76532366

　　累加方案可以参考：线程最快累加方案（二十三）

5、fulladdCount 方法

// x = 1，wasUncontended = false
// 添加计算数量，到baseCount 和 counterCells 数组中
private final void fullAddCount(long x, boolean wasUncontended) {
    int h;// 线程指针哈希
    if ((h = ThreadLocalRandom.getProbe()) == 0) {
        ThreadLocalRandom.localInit();      // force initialization
        h = ThreadLocalRandom.getProbe(); // 线程指针哈希
        wasUncontended = true; // 无竞争
    }

    // 碰撞
    boolean collide = false;                // True if last slot nonempty
    for (;;) {


        CounterCell[] as; CounterCell a; int n; long v;
        // as 不为空  & 
        // 初始化counterCells数组完成情况
        if ((as = counterCells) != null && (n = as.length) > 0) {
            //    as[(n - 1) & h] 利用线程指针哈希计算在counterCells的数组位置。
            //    如果当前位置为没有构造过CounterCell，那么近进入然后构造一个
            if ((a = as[(n - 1) & h]) == null) {
                // cellsBusy == 0 表示:
                // 没有正在进行扩容CounterCell数组或者初始化CounterCell,或者正在插入新节点
                if (cellsBusy == 0) {            // Try to attach new Cell
                    // 创建一个计算单元格
                    CounterCell r = new CounterCell(x); // Optimistic create
                    // CAS设置标志位cellsBusy
                    if (cellsBusy == 0 &&
                        U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {

                        boolean created = false;
                        try {               // Recheck under lock
                            // 再次检查是否符合条件，符合就创建放入然后break结束当前函数
                            CounterCell[] rs; int m, j;
                            if ((rs = counterCells) != null &&
                                (m = rs.length) > 0 &&
                                rs[j = (m - 1) & h] == null) {
                                rs[j] = r;
                                created = true;
                            }
                        } finally {
                            // 释放cellsBusy 修改值为 0
                            cellsBusy = 0;
                        }
                        if (created)
                            // 创建成功，结束循环，否则继续循环
                            break;
                        continue;   
                                // Slot is now non-empty
                    }
                }
                // 有其他线程在操作 cellsBusy == 1的情况
                collide = false;
            }
            // as[(n - 1) & h] 不为空，表示存在竞争
            else if (!wasUncontended)       // CAS already known to fail
                // 修改竞争变量
                wasUncontended = true;      // Continue after rehash

            // 如果当前线程对应CounterCell数组下标存在对应的实例，
            // 那么直接用该实例的 value 相加即可
            else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
                // value 相加成功
                // 结束循环
                break;
            // counterCells数组已经更新
            else if (counterCells != as || n >= NCPU)
                collide = false;            // At max size or stale

            // 当前线程插入时，因为其他某种原因失败失败，重置标志重来
            else if (!collide)
                collide = true;

            // 无人进行扩容CounterCell数组，获取CELLSBUSY 使用权
            else if (cellsBusy == 0 &&
                     U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                // 除了当前表被更新以外的其他原因来到这里那么进行扩容数组。
                try {
                    // 这里扩容是由于哈希碰撞以上的else if 都没有解决 
                    // 所以doug lea 再次扩容降低 并发所带来的自旋次数
                    if (counterCells == as) {// Expand table unless stale
                        // 新建一个是原计数器单元格表数组 2倍 的数组
                        CounterCell[] rs = new CounterCell[n << 1];
                        // 复制原数组元素到新数组
                        for (int i = 0; i < n; ++i)
                            rs[i] = as[i];
                        // 将新数组赋值给属性counterCells
                        counterCells = rs;
                    }
                } finally {
                    // 释放cellsBusy
                    cellsBusy = 0;
                }
                // 碰撞标识设为false
                collide = false;
                continue;                   // Retry with expanded table
            }
            // 更新线程指针哈希，相当于换个位置插入值
            h = ThreadLocalRandom.advanceProbe(h);
        }
        // 初始化counterCells数组
        // 如果counterCells为空 那么进行初始化counterCells数组
        // cellsBusy == 0标识 当前表没有在扩容操作等
        // counterCells == as 防止多线程 已经修改counterCells
        // U.compareAndSwapInt(this, CELLSBUSY, 0, 1) 标识正在对counterCells扩容或初始化
        // 修改cellsBusy 的值为 1
        else if (cellsBusy == 0 && counterCells == as &&
                 U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
            boolean init = false;
            try {                           // Initialize table

                if (counterCells == as) {
                    // 新建一个长度为2的计数器单元格表数组
                    CounterCell[] rs = new CounterCell[2];
                    // 1 与 线程指针哈希 计算，得到 0 或 1
                    // h是线程的一个序列值，可以简单理解为线程特有的一个线程指针哈希
                    // 当前线程得到一个特定位置的CounterCell[] rs下标然后放置添加元素数量
                    rs[h & 1] = new CounterCell(x);
                    // 将新计数器单元格表数组 赋值给 counterCells
                    counterCells = rs;
                    // 初始化 完成
                    init = true;
                }
            } finally {
                // 修改cellsBusy 的值为 0
                cellsBusy = 0;
            }
            if (init)
                // 结束循环
                break;
        }
        // 修改 baseCount 的值 +1
        else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
            break;                          // Fall back on using base
    }
}

6、transfer() 方法

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;

        // 每个线程处理桶的最小数目，可以看出核数越高步长越小，最小16个。
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) 
            stride = MIN_TRANSFER_STRIDE; // subdivide range

        // 如果新数组参数为空，去创建数组
        if (nextTab == null) {
            try {
                //扩容到2倍
                @SuppressWarnings("unchecked")
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];  
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                //扩容保护
                sizeCtl = Integer.MAX_VALUE;  
                return;
            }
            // 给属性nextTable 赋值
            nextTable = nextTab;
            // 扩容总进度，>=transferIndex的桶都已分配出去。
            transferIndex = n;  
        }

        // 新数组长度
        int nextn = nextTab.length;
        // 扩容时的特殊节点，扩容期间的元素查找要调用其find()方法在nextTable中查找元素。
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab); 
        // 当前线程是否需要继续寻找下一个可处理的节点
        boolean advance = true;
        // 所有桶是否都已迁移完成。
        boolean finishing = false; 

        // i从0开始循环旧数组-------
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;

            // 此循环的作用是确定当前线程要迁移的桶的范围或通过更新i的值确定当前范围内下一个要处理的节点。
            while (advance) {

                int nextIndex, nextBound;
                // 每次循环都检查结束条件
                if (--i >= bound || finishing)  
                    advance = false;
                // 迁移总进度<=0，表示所有桶都已迁移完成
                // nextIndex 初始值为 tab.length
                else if ((nextIndex = transferIndex) <= 0) {  
                    i = -1;
                    advance = false;
                }
                // CAS修改 transferIndex 
                // transferIndex减去已分配出去的桶
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) { 
                    // 确定当前线程每次分配的待迁移桶的范围为[bound, nextIndex)
                    // 从尾部开始分配移动范围 ，比如 n = 16，步长stride 是 8
                    // 第一次的移桶范围就是 [8，16）
                    bound = nextBound; // bound 8
                    i = nextIndex - 1; // 15
                    advance = false;
                }

            }
            // 当前线程自己的活已经做完或所有线程的活都已做完，
            // 第二与第三个条件应该是下面让"i = n"后，再次进入循环时要做的边界检查。
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                //所有线程已干完活，最后才走这里。
                if (finishing) {  
                    // 给属性nextTable 清空值
                    nextTable = null;
                    // 替换新table
                    table = nextTab;  
                    // 调sizeCtl为新容量0.75倍。
                    sizeCtl = (n << 1) - (n >>> 1); 
                    return;
                }
                //当前线程已结束扩容，sizeCtl-1表示参与扩容线程数-1。
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    //还记得addCount()处给sizeCtl赋的初值吗？相等时说明没有线程在参与扩容了，
                    // 置finishing=advance=true，为保险让i=n再检查一次。
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)   
                        return;
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            // f指向 tab[i]
            else if ((f = tabAt(tab, i)) == null)
                // 如果i处是ForwardingNode表示第i个桶已经有线程在负责迁移了。
                advance = casTabAt(tab, i, null, fwd);  
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
                synchronized (f) {  //桶内元素迁移需要加锁。
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        if (fh >= 0) {  //>=0表示是链表结点

                            // 由于n是2的幂次方（所有二进制位中只有一个1)，
                            // 如 n=16(0001 0000)，
                            // 因为节点在同一个桶中，因为(n - 1) & hash)，值是相同的，即二进制后面4位相同
                            // 第5位为1，那么（hash & 16） 后的值第5位只能为0或1。所以可以根据hash&n的结果将所有结点分为两部分。
                            int runBit = fh & n;
                            // f指向 tab[i]
                            Node<K,V> lastRun = f;
                            // 循环查找
                            // 找出最后一段完整的fh&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;
                            }
                            //lastRun之前的结点因为 fh&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);
                            }
                            // 低位链表放在i处
                            setTabAt(nextTab, i, ln);
                            // 高位链表放在i+n处
                            setTabAt(nextTab, i + n, hn);
                            // 在原table中设置ForwardingNode节点以提示该桶扩容完成。
                            setTabAt(tab, i, fwd); 

                            advance = true;
                        }
                        else if (f instanceof TreeBin) { //红黑树处理。
                            ...

　　transfer 方法，实现步骤大致如下:

　　1、计算单线程扩容是，处理桶的数量，即步长，最小值为16

　　2、创建新数组，数组长度是原来的2倍

　　3、从table数组后面开始分配，一步步长数量的同，交由当前线程进行扩容处理

　　　　(1) 如果table[i]是链表节点，将链表拆开成高位与低位，2个链表，处理放到新数组中

　　　　(2)  如果table[i]是树节点，将链表拆开成高位与低位，2个链表

　　　　　　- 链表数量小于等于6，转换成链表节点，放到新数组中

　　　　　　- 链表数量大于6，处理成黑红树，挂在TreeNode节点下，放到数组中

　　注：加载因子，固定是0.75，由大量研究试验所得经验，不能改变

　　并发扩容总结

1. 单线程新建nextTable，新容量一般为原table容量的两倍。

2. 每个线程想增/删元素时，如果访问的桶是ForwardingNode节点，则表明当前正处于扩容状态，协助一起扩容完成后再完成相应的数据更改操作。

3. 扩容时将原table的所有桶倒序分配，每个线程每次最小分配16个桶，防止资源竞争导致的效率下降。单个桶内元素的迁移是加锁的，但桶范围处理分配可以多线程，在没有迁移完成所有桶之前每个线程需要重复获取迁移桶范围，直至所有桶迁移完成。

4. 一个旧桶内的数据迁移完成但不是所有桶都迁移完成时，查询数据委托给ForwardingNode结点查询nextTable完成（可以find()方法）。

5. 迁移过程中sizeCtl用于记录参与扩容线程的数量，全部迁移完成后sizeCtl更新为新table容量的0.75倍。

7、helpTransfer() 方法

final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
    Node<K,V>[] nextTab; int sc;
    // 根据节点类型是否正在扩容
    if (tab != null && (f instanceof ForwardingNode) &&
        (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
        int rs = resizeStamp(tab.length);
        while (nextTab == nextTable && table == tab &&
               (sc = sizeCtl) < 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;
            }
        }
        return nextTab;
    }
    return table;
}

8、gei() 方法

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    // 获取hash 值
    int h = spread(key.hashCode());
    // 判断table 与 对应table[i] 是否为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 判断hash值是否相等
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // 判断是否在扩容
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 循环查找链表（红黑树中也存在链表）
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

　get实现步骤大致如下:　　

　　1、通过 hash 值获取该 key 映射到的桶。

　　2、桶上的 key 就是要查找的 key，则直接命中。

　　3、桶上的 hash 表示正在扩容，则帮哈希表扩容。

　　4、桶上的 key 不是要查找的 key，则查看后续节点，通过循环遍历链查找该 key　　　　

9、remove() 方法

public V remove(Object key) {
    return replaceNode(key, null, null);
}


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;
        // 判断table 和 hash对应的table[i] 是否为空
        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) {
                    // fh>=0，表示节点所在的是链表
                    if (fh >= 0) {
                        validated = true;
                        // 遍历链表，查找对应的key，value
                        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;
                        // 根据root节点去查找
                        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)
                        // 计数减1
                        addCount(-1L, -1);
                    return oldVal;
                }
                break;
            }
        }
    }
    return null;
}

10、size() 方法

public int size() {
    // 统计元素数量
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}

final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    // 基本计数器
    long sum = baseCount;
    if (as != null) {
        // 循环遍历 计数器数组，累加
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

五、ConcurrentHashMap源码分析 

　　

五、ConcurrentHashMap源码总结

　　1、ConcurrentHashMap 创建时的数组为空; 当加入第一个元素时，进行第一次扩容时，创建数组，默认容 量大小为 16。

　　2、ConcurrentHashMap 阀值固定是容量n的0.75倍，加载因子0.75是固定的

　　3、ConcurrentHashMap 每次扩容都以当前数组大小的 2 倍去扩容，多线程参与，各线程的扩容步长最小值为16。

　　4、ConcurrentHashMap 在扩容是，其他put线程与remove线程会参与到扩容中来。

　　5、ConcurrentHashMap 的 链表长度大于8，且数组容量大于等于64，链表转化成红黑树，红黑树是挂在TreeNode节点下的。

　　6、ConcurrentHashMap 是线程安全的，在put 或 remove 操作时，使用的是synchronized关键字，锁住的对象是table[i](数组上的桶)，不影响其他桶的使用。 

参考文章

　　1、https://blog.csdn.net/tp7309/article/details/76532366

　　2、https://blog.csdn.net/weixin_43185598/article/details/87938882