上一篇文章并发编程之synchronized的前世今生，我们介绍了锁的分类，synchronized的用法，synchronized的实现原理，对象的内存布局，以及锁膨胀的过程。这篇文章中，我们将对JDK 1.8的ConcurrentHashMap的源码做个解读。本文主要包含以下几部分：

前言

基本原理

基础组件

put

扩容

get

size

总结

1. 前言

并发编程的时候，除了各种锁的应用，还涉及到并发工具类、并发集合的应用。而提到集合又不得不提Map，提到多线程环境下的Map实现，又不得不说ConcurrentHashMap。本文将对ConcurrentHashMap的源码做部分解读。在开始之前，我们先思考几个问题：

Q1：为什么多线程环境下不能使用HashMap？
A：多线程环境下HashMap可能会导致链表闭环，造成CPU100%
Q2: JDK 1.8 HashMap是否是线程安全的？
A：JDK 1.8虽然解决了链表闭环的问题，但是由于hashmap在设计的时候并未考虑线程安全的问题，所以在多线程环境中使用，仍然可能造成数据丢失，并不是线程安全的。
Q3：ConcurrentHaspMap的数组长度为什么只能是2的N次方？
A：为了避免hash冲突，尽可能的散列数据。（下文会详细讲解）
Q4：ConcurrentHaspMap是如何保证线程安全的？
A：通过CAS+synchronized来保证。（下文会详细讲解）
Q5：ConcurrentHaspMap中数据存储的可能形式有哪些？
A：数组、链表、红黑树
Q6：ConcurrentHaspMap的扩容机制是什么？
A：多线程通过CAS+synchronized并发扩容。（下文会详细讲解）。

2. 基本原理

内部持有一个Node[]，用来存放key,value。
1.1 这个数组的默认长度是16，并且只会在第一次put的时候才会初始化（lazy init）。
put 的时候要通过运算得到应存放的数组下标，然后根据不同的情况决定初始化数组、插入链表、插入红黑树或者协助扩容。
2.1 先进行hash扰动。
2.2 数组如果还未进行初始化，则先进行初始化。初始化默认大小为16，如果指定了初始化大小，则会计算一个>=指定值，且为2的N次幂的数字，且最接近当前参数的数字作为初始长度。
2.3 当前位置==null，则直接通过CAS插入数据。
2.4 如果当前数组正在进行扩容，则协助扩容。
2.6 当前位置!=null。如果当前节点是红黑树，则直接插入树中。否则作为链表插入链表插入或者更新。
2.7 插入成功后，如果是链表，则检查是否需要转成红黑树。转换条件是链表节点数>=8，且数组长度>64。
2.8 最后更新size的值，并且检查是否需要扩容。
get的时候同样通过运算得到应存放的数组下标，然后进行遍历。
3.1 先进行hash扰动，使用hash&(n-1)得到数组索引。
3.2 取索引对应的数据进行遍历。可能是链表、红黑树，也可能是FWD节点。
size++的时候，先尝试用更新volatile baseCount，更新失败再尝试定位到具体的CounteCell，用CAS或者直接更新其volatile value。

从上面的流程可以看到，一个数据在ConcurrentHashMap中可能存储在链表或者红黑树中。

ConcurrentHashMap数据结构图.png

put流程

put.png

3. 基础组件

要搞清楚ConcurrentHashMap的原理，有几个重要属性和类需要先做说明。、

属性

数组最大长度，2的30次方。之所以不是2的32次方，是因为前两位用于控制
private static final int MAXIMUM_CAPACITY = 1 << 30;
默认数组大小16
private static final int DEFAULT_CAPACITY = 16;
链表转红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
红黑树转链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
链表转红黑树时需满足的最小数组长度
static final int MIN_TREEIFY_CAPACITY = 64;
表示正在转移
static final int MOVED     = -1; // hash for forwarding nodes
红黑树的hash值
static final int TREEBIN   = -2; // hash for roots of trees
static final int RESERVED  = -3; // hash for transient reservations
//hash扰乱时用来将数值转换为正数
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
CPU可用核心个数
static final int NCPU = Runtime.getRuntime().availableProcessors();


存放数据的数组
transient volatile Node[] table;
要转移到的目标数组，只有扩容的时候非空
private transient volatile Node[] nextTable;‘
计数器conut，用来统计size
private transient volatile long baseCount;
-1/初始化 0/默认值  >0 未初始化之前的长度/初始化之后的阈值  <-1 特殊数字+n记录正在扩容的线程数
private transient volatile int sizeCtl;
近似于多线程扩容时当前线程可以取到的最大下标
private transient volatile int transferIndex;
用来计数的数组
private transient volatile CounterCell[] counterCells;

类
Node-链表类，用来存储key-value

static class Node implements Map.Entry {
        final int 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;
        }

TreeNode-用来构建TreeBin，红黑树的节点

static final class TreeNode extends Node {
        TreeNode parent;  // red-black tree links
        TreeNode left;
        TreeNode right;
        TreeNode prev;    // needed to unlink next upon deletion
        boolean red;

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

TreeBin-存放红黑树的首节点和根节点

 static final class TreeBin extends Node {
        TreeNode root;
        volatile TreeNode 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; /

ForwardingNode-占位节点，插入链表头部，表示正在被转移

static final class ForwardingNode extends Node {
        final Node[] nextTable;
        ForwardingNode(Node[] tab) {
            super(MOVED, null, null, null);
            this.nextTable = tab;
        }

4. put

final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        hash扰乱
        int hash = spread(key.hashCode());
        int binCount = 0;
        死循环
        for (Node[] tab = table;;) {
            Node f; int n, i, fh;
            数组未初始化，则进行初始化
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            所属节点不为空，则CAS插入
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            帮助扩容
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                存在hash冲突，则锁住头节点
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        链表
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        红黑树
                        else if (f instanceof TreeBin) {
                            Node p;
                            binCount = 2;
                            if ((p = ((TreeBin)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    超过阈值，链表转红黑树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        size+1&检查是否需要扩容
        addCount(1L, binCount);
        return null;
    }

从源码中，我们梳理出整个put的流程如下：

hash扰动

死循环put，直到成功
2.1 数组未初始化，则进行初始化
2.2 元素为空，则进行CAS插入
2.3 元素正在转移，则协助转移
2.4 存在hash冲突，则锁住头节点，进行插入

size+1&检查扩容

下面，我们分别来看下这些步骤

4.1 hash扰动

    static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;
    }

这里的运算逻辑很明确，原始hashcode先右移16位，然后与原始hashcode进行异或运算，最后在与HASH_BITS进行与运算。那么，为什么要这么运算呢？
假设有两个hashcode，分别为2450063367和3223977991，数组长度为16.
不进行扰动

hashcode & (table.length-1)
----------------------------------                                    ---------------------------------- 
2450063367 & (16-1)                                                   3223977991& (16-1)
----------------------------------                                    ---------------------------------- 
1001001000001001 0000000000000111                                     1100000000101010 0000000000000111
&                                                                     &
0000000000000000 0000000000001111                                     0000000000000000 0000000000001111
----------------------------------                                    ----------------------------------
结果：                                                                 结果：
0000000000000000 0000000000000111                                     0000000000000000 0000000000000111
即十进制 7                                                             同样为十进制 7

进行扰动

(h ^ (h >>> 16))& (table.length-1)
-------------------------------------------                        -------------------------------------------
2450063367^(2450063367 >>> 16) &(16-1)                             3223977991^(3223977991>>> 16) &(16-1)
-------------------------------------------                        -------------------------------------------
1001001000001001 0000000000000111                                  1100000000101010 0000000000000111
>>> 16                                                             >>> 16
0000000000000000 1001001000001001                                  0000000000000000 1100000000101010
^                                                                  ^
1001001000001001 0000000000000111                                  1100000000101010 0000000000000111
=                                                                  =
1001001000001001 1001001000001110                                  1100000000101010 1100000000101101
&                                                                  &
0000000000000000 0000000000001111                                  0000000000000000 0000000000001111
--------------------------------------------                       --------------------------------------------
结果:                                                              结果:
0000000000000000 0000000000001110                                  0000000000000000 0000000000001101
即十进制14                                                         即十进制13

可以发现两个hashcode在不进行扰动的时候，可能得到相同的索引即hash冲突。但是经过扰动计算后，可以得到不同的索引。从而我们可以得到结论：hash扰动的目的是让同一个hash值的低位和高位的特征进行混合，从而尽可能得到一个独一无二的hash值，从而减少hash冲突。

至于这里最后为什么要 & HASH_BITS，即 & 0x7fffffff，则是为了将扰动后的hashcode转成正数，因为hashcode<0在ConcurrentHashMap中有特定的含义（-1：转移中 -2：红黑树）。

4.2 数组初始化

ConcurrentHashMap的初始化采用的是懒加载的方式，即第一次put的时候才会初始化（与HashMap类似）。

构造方法

    构造方法
    public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        传进来的参数大于最大容量的一倍，则直接使用最大容量。因为默认都是2倍扩容，当大于等于最大值的一半时，再进行2倍扩容反而得不偿失，不如直接使用最大容量。
        小于最大容量的一半，则会计算出一个大于等于1.5*initialCapacity+1，且为2的N次幂的数字，作为初始数组长度。
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        在构造函数被调用时，sizeCtl存放的是上面计算得到的初始数组长度
        this.sizeCtl = cap;
    }

可以看到构造函数仅仅计算了一个需要初始的数组长度，并且赋值给sizeCtl，并未实际进行数组的初始化。这点也很好理解，如果我仅仅是new ConcurrentHashMap()，但是之后并未使用它，在put的时候初始化就可以避免内存的浪费。

初始化数组
ConcurrentHashMap如何保证数组初始化时候的线程安全呢？答案是通过CAS+volatile+自旋。

 private final Node[] initTable() {
        Node[] tab; int sc;
       数组为空
        while ((tab = table) == null || tab.length == 0) {
            有其它线程正在进行初始化，当前线程放弃本次CPU执行权，等待下次调度
            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) {
                        如果有传入初始化长度，则使用计算后的初始化长度，否则使用16
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node[] nt = (Node[])new Node[n];
                        table = tab = nt;
                        设置sizeCtl为3/4*初始长度，即0.75*初始长度。这个时候sizeCtl表示的是触发扩容的阈值。
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

初始化过程.png

tableSizeFor

    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;
    }

从tableSizeFor的方法名就可以知道，这个方法是用来计算数组的长度。我们都知道数组的长度一定是2的N次幂，那么这个方法的返回值一定是2的N次幂，且最接近给定的参数c。那么是如何实现的呢？

假设c=11
-----------------------------
int n=11-1=10;
-----------n |= n >>> 1------------------
n：            00000001010（省略高位0，下同）
n>>>1          00000000101
n|n>>>1        00000001111
n:             00000001111
------------------------------------------
-----------n |= n >>> 2------------------
n>>>2          00000000011
n|n>>>2        00000001111
n:             00000001111
------------------------------------------
-----------n |= n >>> 4------------------
n>>>4          00000000000
n|n>>>4        00000001111
n:             00000001111
------------------------------------------
-----------n |= n >>> 8------------------
n>>>8          00000000000
n|n>>>8        00000001111
n:             00000001111
------------------------------------------
-----------n |= n >>> 16------------------
n>>>16          00000000000
n|n>>>16        00000001111
n:             00000001111
------------------------------------------
n=00000001111 即十进制 15
return n+1=16

可以看到，核心原理是将给定数字的从第一个非0位置开始，全部转换为1，放在上面的例子里就是将二进制1010转换为1111，最后再加上1，刚好是我们想要的2的N次幂。至于为什么要是2的N次幂，我们放在下面会说。

4.3 待插入节点为空CAS插入

元素为空，则插入
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }

    transient volatile Node[] table;
    static final  Node tabAt(Node[] tab, int i) {
        return (Node)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }

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

这里有两个值得思考的问题：

为什么Node[] table定义成volatile类型，还要用unsafe.getObjectVolatile呢？

我们都知道volatile利用MESI协议（缓存一致性协议）来保证变量的可见性。那么这里为什么还要用unsafe.getObjectVolatile呢，我的理解是table虽然是volatile的，但是只是table这个引用是多线程之间可见的。但是具体到table里的每个元素，则只用volatile是无法保证可见性的。

为什么(n - 1) & hash来计算索引，而不直接使用hash%n呢？

作为一个容器，最重要的标准之一就是效率。显然对计算机而言，位运算比%要高效的多。

为什么这里的n必须是2的N次幂，可以为其它数字吗，比如15，18？

这里的n必须是2的N次幂，不可以为其它数字，即使调用构造函数时你传入了15，最终也只会计算得到一个2的N次幂，来作为初始化数组的长度。这么做的目的是使计算得到的下标i，尽可能分散，也就是尽可能减少hash冲突。

假设n=15                                                                                   假设n=16
则n-1=14                                                                                   则n-1=15
假设hashcode=xxxx（省略高位0，下同）                                                        假设hashcode=xxxx
---------------------------------                                                        ---------------------------------
1110                                                                                     1111  
& hash                                                                                   & hash
xxxx                                                                                     xxxx
---------------------------------                                                       ---------------------------------
已看到，从左至右
第一位可能的值有两种 0/1                                                                 第一位可能的值有两种 0/1
第二位可能的值也有两种 0/1                                                               第二位可能的值也有两种 0/1
第三位可能的值也有两种 0/1                                                               第三位可能的值也有两种 0/1
第四位的值则只能是 0，无论x是0还是1                                                       第四位可能的值也有两种 0/1  
可能的组合种类 2*2*2=8种                                                                 可能的组合种类 2*2*2*2=16种

从上面的例子很清楚的可以看到，n为2的N次幂可以数据的分布更加分散，更大可能的降低hash冲突，同时也保证了(n-1)&hash==hash%n。

4.4 协助扩容

如果put的时候，发现数组正在扩容，则协助扩容，毕竟扩容是一个耗时的操作，多线程扩容可以大大加快扩容的速度。那么是如何实现的呢？

    final Node[] helpTransfer(Node[] tab, Node f) {
        Node[] nextTab; int sc;
       数组不为空&当前节点为FWD节点&转移的目标数组不为空
        if (tab != null && (f instanceof ForwardingNode) &&
            (nextTab = ((ForwardingNode)f).nextTable) != null) {
            根据数组长度计算一个唯一的数据戳（一个很大的负数）
            int rs = resizeStamp(tab.length);
           检查nextTab和table都未发生更改，且sizeCtl<0
            while (nextTab == nextTable && table == tab &&
                   (sc = sizeCtl) < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || transferIndex <= 0)
                    扩容结束
                    break;
                将sc设置未sc+1
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                    扩容
                    transfer(tab, nextTab);
                    break;
                }
            }
            return nextTab;
        }
        return table;
    }

这里有几个退出扩容的条件值得注意

(sc >>> RESIZE_STAMP_SHIFT) != rs 不太明白啥意思
sc == rs + 1，没有线程进行扩容了即扩容结束了
sc == rs + MAX_RESIZERS，达到最大帮助线程数65535
transferIndex <= 0 可用区间<=0,即所有的区间都被领取完毕，没有可用区间

4.5 锁住头节点，插入数据

如果节点不为空，且hash值!=-1，则证明存在hash冲突，则需要使用synchronized进行加锁。从这里可知，如果多个线程同时put，可能会阻塞（计算得到的索引相同）

 V oldVal = null;
                synchronized (f) {
                    再次检查
                    if (tabAt(tab, i) == f) {
                        链表
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        红黑树
                        else if (f instanceof TreeBin) {
                            Node p;
                            binCount = 2;
                            if ((p = ((TreeBin)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                如果是链表，则检查是否需要转数
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }

代码逻辑比较清晰，链表的话则是替换或者插入链表尾部，红黑树的话，则是构造成TreeBin或者TreeNode

链表转红黑树

    private final void treeifyBin(Node[] tab, int index) {
        Node b; int n, sc;
        if (tab != null) {
            只有当链表长度大于=8&数组长度小于64时才会触发转树的操作
            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                数组长度小于64时优先选择扩容
                tryPresize(n << 1);
            else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
                锁住头节点，链表转树
                synchronized (b) {
                    if (tabAt(tab, index) == b) {
                        TreeNode hd = null, tl = null;
                        for (Node e = b; e != null; e = e.next) {
                            TreeNode p =
                                new TreeNode(e.hash, e.key, e.val,
                                                  null, null);
                            if ((p.prev = tl) == null)
                                头节点
                                hd = p;
                            else
                                tl.next = p;
                            tl = p;
                        }
                        volatile更新数据，树的构建时在TreeBin的构造方法里实现的
                        setTabAt(tab, index, new TreeBin(hd));
                    }
                }
            }
        }
    }

根据TreeNode头节点，构建整个红黑树

       TreeBin(TreeNode b) {
            super(TREEBIN, null, null, null);
            this.first = b;
            TreeNode r = null;
            for (TreeNode x = b, next; x != null; x = next) {
                next = (TreeNode)x.next;
                x.left = x.right = null;
                if (r == null) {
                    x.parent = null;
                    x.red = false;
                    r = x;
                }
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class kc = null;
                    for (TreeNode p = r;;) {
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);
                            TreeNode xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            r = balanceInsertion(r, x);
                            break;
                        }
                    }
                }
            }
            this.root = r;
            assert checkInvariants(root);
        }

4.6 size+1&检查扩容

当数据成功插入后，就需要将size+1，并且检查是否需要扩容了。在单线程下很方便的size++操作，在多线程下实现起来却是比较复杂的，因为既要实现线程安全，又要尽可能的高效。

   private final void addCount(long x, int check) {
       用来计算数字的类，下面会详细介绍
        CounterCell[] as; long b, s;
        as!=null
        if ((as = counterCells) != null ||
            CAS更新BASECOUNT为BASECOUNT+1失败，则利用CounterCell计数
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            CounterCell a; long v; int m;
            boolean uncontended = true;
            as 为空||as的长度为0||CAS更新CounterCell[i]的value值失败
            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)
                return;
            统计总元素数量
            s = sumCount();
        }
        if (check >= 0) {
            Node[] tab, nt; int n, sc;
            元素数量操作阈值(0.75*数组容量)&&table!=null&&数组长度小于最大长度
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                   (n = tab.length) < MAXIMUM_CAPACITY) {
                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;
                    扩容前将SIZECTL设置为SIZECTL+1
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                        扩容
                        transfer(tab, nt);
                }
                没有其它线程扩容，当前线程为第一个扩容的线程
                成功将SIZECTL更新为(rs << RESIZE_STAMP_SHIFT) + 2的线程，即为首个扩容线程
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
                s = sumCount();
            }
        }
    }

这里有两个值得注意的点：

第一个进行扩容的线程会将设置SIZECTL= (rs << RESIZE_STAMP_SHIFT) + 2
后续在扩容未结束的时间段中，每进入一个线程都会设置SIZECTL=SIZECTL+1，结束后设置未SIZECTL-1。
扩容的逻辑中会判断SIZECTL的值，从而确定扩容是否结束

5. 扩容

前面我们在put方法的介绍里，多次提到了扩容。扩容作为一个耗时的操作，多线程扩容如何保证线程安全和兼顾效率的呢？

扩容流程

计算步长。具体计算方法是：数组长度/8/可用核心数，如果得到的数字小于16，则默认为16。
初始化nextTab和transferIndex。其中nextTab为原数组的两倍，transferIndex为原数组的长度。
死循环扩容
3.1 进入While循环，分配初始区间。这里可以得到两个变量 i和nextBound，其中i代表的是当前下标且初始值为数组长度-1，而nextBound为当前线程可以取到的最小下标，即当前取到的可处理区间为(nextBound,i-1)，小于nextBound时需要重新取空间或者结束扩容。每次i--，控制整个区间内的节点从后往前完成扩容。这里同样会得到一个变量advance，代表当前节点是否处理完毕。
3.2 while循环结束，判断扩容是否结束。如果扩容结束，则更新table的指向为nextTab，同时更新sizeCtl的值为1.5n。如果扩容未结束且无法领取新的区间且当前有其它线程在扩容，当前线程退出。如果扩容未结束且无法领取新的区间且当前无其它线程正在扩容，则finishing置为true，再重新检查整个table。
3.3 i对应的槽位为空，则插入FWD节点占位（插入的是oldtable），其它线程put的时候发现是FWD节点，触发协助扩容。
3.4 i节点不为空，且已有FWD节点，则跳过当前节点
3.5 以上都不满足，说明当前节点i有实际值，需要做数据转移。到这里才开始真正的把oldtable里的值往newtable里转移。
数据转移
4.1 锁住表头，防止转移的时候其它线程往这个节点插入数据。
4.2 如果当前槽位的元素类型是链表，则通过遍历链表的每个元素，通过hash&length，做高低位拆分。为0放低位，否则放高位。低位下标保持不变，高位则为原始下标+n。
4.3 如果当前槽位的元素类型是红黑树，则通过遍历红黑树，按照同样的方式拆分。如果拆分后的树长度<=6，则重新转链表。

扩容的过程是整个ConcurrentHashMap中最复杂的地方，因为涉及到多线程扩容，又要兼顾数据安全和效率。

扩容过程中的数据变化.png

上述扩容过程的详细流程图如下：

扩容过程.png

源码
清楚了上面的流程，再结合源码来看就相对容易理解一点了。

 private final void transfer(Node[] tab, Node[] nextTab) {
        int n = tab.length, stride;
        计算步长
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        初始化nextTab 
        if (nextTab == null) {            // initiating
            try {
                @SuppressWarnings("unchecked")
                Node[] nt = (Node[])new Node[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            transferIndex = n;
        }
        int nextn = nextTab.length;
        ForwardingNode fwd = new ForwardingNode(nextTab);
        advance标识当前节点是否已完成转移，为true则可以继续进行到下一个节点
        boolean advance = true;
        整个扩容是否已完成
        boolean finishing = false; // to ensure sweep before committing nextTab
        死循环转移
        for (int i = 0, bound = 0;;) {
            Node f; int fh;
            while (advance) {
                int nextIndex, nextBound;
                超过最小下标||已完成
                if (--i >= bound || finishing)
                    advance = false;
                没有可领取的区间，这里也做了nextIndex的赋值，因为transferIndex是volatile修饰的，
               且下面用其它线程用CAS更新了transferIndex的值，因此这里其它线程可以感知到transferIndex的更新。
                之所以transferIndex是volatile修饰，但是还用CAS更新的原因是：要得到是否能更新成功的结果，而不是直接改掉。
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                将TRANSFERINDEX更新成nextBound
                成功用CAS将TRANSFERINDEX更新成nextBound的线程，即成功领取到了（nextBound,i）的区间
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            判断是否完成
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                完成
                if (finishing) {
                    将table的引用指向nextTab
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                设置sc=sc-1
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    有其它线程在进行扩容，当前线程结束后直接退出
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    重新开始循环，recheck
                    i = n; // recheck before commit
                }
            }
            下标i对应的位置为空，则将oldtable的对应i设置为FWD节点
            其它线程在put的时候，发现待插入的节点为FWD，则协助扩容
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            当前节点为FWD，则跳过
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
                当前节点存在数据，则锁住头节点，防止数据转移的时候其它线程进行插入
                synchronized (f) {
                    重新检查
                    if (tabAt(tab, i) == f) {
                        ln低位，hn高位
                        Node ln, hn;
                        链表处理扩及
                        if (fh >= 0) {
                            用hashcode&数组长度计算runBit，runBit只有两种结果 0/非0
                            int runBit = fh & n;
                            Node lastRun = f;
                            for (Node p = f.next; p != null; p = p.next) {
                                循环整个链表，计算每个元素的p.hash & n，如果与已存在的runBit不同，则赋值给runBit
                                用runBit来找到最后一个不同的位置，即最后一个高低位切割的位置，这样可以重用最后一个runBit对应的链表
                                int b = p.hash & n;
                                与runBit不相同，则证明当前元素和lastRun处于不同的高低位，要进行切割
                                if (b != runBit) {
                                    赋值给runBit，注意这里会存在多次赋值的情况，具体取决与链表的高低位切割情况
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            经过上面的循环，runBit此时为最后一个要切割的链表节点的计算结果，lastRun为最后一个要切割的链表节点
                            if (runBit == 0) {
                                为0放低位
                                ln = lastRun;
                                hn = null;
                            }
                            else {
                                非0放高位
                                hn = lastRun;
                                ln = null;
                            }
                            再次循环链表，这里只循环到最后一个切割点，并不需要循环整个链表，实现链表的复用
                            for (Node 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(ph, pk, pv, ln);
                                else
                                    hn = new Node(ph, pk, pv, hn);
                            }
                            将得到的低位链表插入到新的数组中，低位链表的下标不变
                            setTabAt(nextTab, i, ln);
                            高位链表的下标为：原始下标+原始数组长度
                            setTabAt(nextTab, i + n, hn);
                            完成当前节点转移后，将当前节点设置为FWD占位节点
                            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);
                                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;
                                }
                            }
                            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;
                        }
                    }
                }
            }
        }
    }

可以看到并发扩容的关键就是利用CAS+volatile+synchronized来实现线程安全的并发控制的。简单概括来说：

定一个volatile修饰的transferIndex
每个线程进来都尝试用CAS将transferIndex更新为自己计算的区间值
每个线程处理自己特定的区间：null节点插入FWD，非空节点做高低位拆分，最后再插入FWD
处理完自己的区间后，判断是否还有区间可领取，或者结束扩容

5.1 高低位拆分

重点来看下最精华的部分，高低位拆分。之所以做高低位拆分，是为了：

通过高低位计算不同的索引，保证扩容之后通过(n-1)&hash 还能命中该hash值对应的元素。试想一下，因为get的时候是通过(n-1)&length定位元素的，如果计算的索引和存放的索引不一致，那get岂不是=null
可以保证尽可能的重用尾部的链表，提高扩容的效率。处理的时候lastRun之后的链表是无需遍历和重新构造的。

高低位拆分主要包括以下步骤：

循环整个链表，得到runBit和lastRun。
根据lastRun的值，得到初始ln/hn
循环整个链表直到lastRun，构建完整ln&hn
按高低位区分插入不同位置，设置oldtable的i节点为FWD

下面用图来说明这个过程：

初始状态。假设数组长度为16，4号桶的位置有一个链表。

高低位拆分初始状态.png

高低位拆分
当对索引4对应的链表进行转移的时候，会进行高低位拆分，将其拆分成高位链表和低位链表。

高低位拆分过程-双循环.png
扩容后的数组

转移后的数组.png

可以看到，经过高低位拆分后，成功将4号桶所在的链表拆分成高位链表和低位链表。其中高位链表的下标=原始下标i+原始数组长度，低位链表的下标长度=原始下标i。

为什么高位链表的下标=原始下标i+原始数组长度，低位链表的下标长度=原始下标i？

----------------------------------
验证数据如下：扩容前长度16->32扩容后长度,Node1(48,“0”，“0”,Node2);Node2(1568,“11”，“11”,null);
-------------------------------扩容前--------------------------------------------------------------------
(16-1)            0000000001111                      |    (16-1)            0000000001111
&                                                    |    & 
48                0000000110000                      |    1568
0                 0000000000000                      |    0                 0011000100000
-------------------------------扩容后--------------------------------------------------------------------
可以看到扩容前，Node1和Node2都在原数组的0号桶中
48&16=16 ,1568&16=0 ，因此推算出Node1扩容后新的索引为16，Node2扩容后新的索引为0
即：(新数组的长度-1)&Node1.hash=原始下标+原始数组长度=16，(新数组的长度-1)&Node2.hash=原始下标=0
即：31&48=0+16=16，31&1568=0
---------------------------------------------------------------------------------------------------------------
(32-1)           00000000000011111                   |  (32-1)                  00000000000011111
&                                                    |  &
48               00000000000110000                   |  1568                    00000011000100000
16               00000000000010000                   |  0                       00000000000000000
---------------------------------------------------------------------------------------------------------------
可以看到(新数组的长度-1)&Node1.hash=原始下标+原始数组长度=16，(新数组的长度-1)&Node2.hash=原始下标=0确实成立。
---------------------------------------------------------------------------------------------------------------

说完了扩容，我们就说完了整个put的相关流程。这里进行多线程环境下的并发put进行简单总结：

如果待插入的槽位为FWD节点，则协助扩容。
如果待插入非FWD，且非空，则锁住表头，进行插入。此时未拿到对应节点的锁的线程，将被阻塞。

6. get

相比于put，get的操作逻辑要简单的多，可以分为以下几步

通过Unsafe.getObjectVolatile获取最新槽位的值
遍历红黑树或者链表查找元素

 public V get(Object key) {
        Node[] tab; Node e, p; int n, eh; K ek;
        hash扰动
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            取最新的值getObjectVolatile
            (e = tabAt(tab, (n - 1) & h)) != null) {
            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里并不会触发协助扩容

7. size

map中的api，除了get和set，最常用的可能就是size了，在单线程的环境中，我们要计数直接++size就可以了，但是在多线程环境下，是如何并发计数的呢？

定义了一个volatile变量baseCount，定义了一个volatile CounterCell[]来实现LongAdder。
每次size++的时候先判断CounterCell[] 是否为空，如果为空，则尝试利用CAS更新baseCount为baseCount+1。如果更新成功，则计数成功。
如果CounterCell[]不为空，或者更新baseCount失败，尝试将不同线程的计数请求分配到不同的CounterCell中，然后利用CAS 更新CounterCell[i]对应的volatile value。类似LongAdder。

计数.png

源码

addCount

private final void addCount(long x, int check) {
        CounterCell[] as; long b, s;
        counterCells非空，则直接利用counterCells计数
        if ((as = counterCells) != null ||
           counterCells为空，则首先尝试更新BaseCount
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            更新BaseCount失败，再利用CounterCell计数
            CounterCell a; long v; int m;
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                直接尝试将CounterCell[i]的vlaue值利用CAS，++
                !(uncontended =
                  U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
                更新失败，死循环处理
                fullAddCount(x, uncontended);
                return;
            }
            if (check <= 1)
                return;
            s = sumCount();
        }

fullAddCount

    // See LongAdder version for explanation
    private final void fullAddCount(long x, boolean wasUncontended) {
        得到一个线程hash值，多次调用相同，但是可以手动改变
        int h;
        if ((h = ThreadLocalRandom.getProbe()) == 0) {
            初始化ThreadLocalRandom
            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;
             CounterCell[] 不为空，证明已经初始化过，则需要定位到其下标i，进行处理
            if ((as = counterCells) != null && (n = as.length) > 0) {
               对应的CounterCell[i]为空
                if ((a = as[(n - 1) & h]) == null) {
                    创建新的CounterCell，这里要保证通过cellsBusy == 0，因为下面要更新CounterCell[]，必须要保证能成功将cellsBusy 变量更新为1，即多个线程相对于CounterCell[]，通过cellsBusy完成竞争
                    if (cellsBusy == 0) {            // Try to attach new Cell
                        CounterCell r = new CounterCell(x); // Optimistic create
                        if (cellsBusy == 0 &&
                            成功更新，则相当于拿到锁
                            U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                            boolean created = false;
                            try {               // Recheck under lock
                                CounterCell[] rs; int m, j;
                                if ((rs = counterCells) != null &&
                                    (m = rs.length) > 0 &&
                                    rs[j = (m - 1) & h] == null) {
                                    赋值给CounterCell[i] 
                                    rs[j] = r;
                                    created = true;
                                }
                            } finally {
                                cellsBusy = 0;
                            }
                            if (created)
                                break;
                            continue;           // Slot is now non-empty
                        }
                    }
                    collide = false;
                }
                else if (!wasUncontended)       // CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
                CounterCell[i]不为空，尝试通过CAS跟新其对应的value值，这里不需要改变CounterCell[i]的指向 
                else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
                    break;
                else if (counterCells != as || n >= NCPU)
                    collide = false;            // At max size or stale
                else if (!collide)
                    collide = true;
                else if (cellsBusy == 0 &&
                         U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                 CounterCell[i]不为空，且用CAS更新value失败，则说明存在竞争，则对CounterCell[]进行扩容
                 扩容的时候，同样要先将cellsBusy 用CAS跟新为1，相当于拿到锁。
                    try {
                        if (counterCells == as) {// Expand table unless stale
                            CounterCell[] rs = new CounterCell[n << 1];
                            for (int i = 0; i < n; ++i)
                                rs[i] = as[i];
                            counterCells = rs;
                        }
                    } finally {
                        cellsBusy = 0;
                    }
                    collide = false;
                    continue;                   // Retry with expanded table
                }
                全部失败后，重新计算hash
                h = ThreadLocalRandom.advanceProbe(h);
            }
            else if (cellsBusy == 0 && counterCells == as &&
                     U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                初始化CounterCell[]
                boolean init = false;
                try {                           // Initialize table
                    if (counterCells == as) {
                        CounterCell[] rs = new CounterCell[2];
                        rs[h & 1] = new CounterCell(x);
                        counterCells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy = 0;
                }
                if (init)
                    break;
            }
            else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
                break;                          // Fall back on using base
        }
    }

8. 总结

我们用了很长的篇幅介绍了ConcurrentHashMap的源码，最后我用几个问题对以上的内容进行总结。

1. CocurrentHashMap是如何保证线程安全的？

从读(get)的层面，利用Unsafe.getObjectVolatile保证读到的是最新的值。从而实现线程安全
从写(put)的层面，利用的是Unsafe+volatile+synchronized来保证线程安全。1）未初始化的时候利用的volatile的可见性保证初始化线程安全。2）初始化后利用Unsafe.getObjectVolatile保证可以拿到最新的槽位值，如果对应位置为空，则尝试用CAS更新数据保证线程安全。3）如果不为空，则利用synchronized锁链表头部保证线程安全，此时其它线程不能对该节点进行写操作。
从扩容的层面，同样利用的是Unsafe+volatile+synchronized来保证线程安全。1）利用volatile保证初始化新数组的可见性。2）利用CAS+nextTable保证每个线程能领取各自的区间。3）利用CAS更新为空的槽位为FWD。4）利用synchronized锁链表的头节点实现线程安全。
从计数(size)的层面，同样利用的是CAS+volatile来实现线程安全，有点类似LongAdder。

2. CocurrentHashMap 什么情况下才会触发扩容？

数组内元素的数量超过阈值（0.75n）时。
添加元素后，发现链表内元素大于等于8，且数组长度小于64时。

3. ConcurrentHashMap 扩容时是否支持读写？

扩容时可以支持读，会使用Unsafe.getObjectVolatile读取最新的值，然后进行遍历。
扩容时遇到写的情况，1）如果当前节点为空，则直接利用CAS写。2）当前节点为FWD，则协助扩容。3）当前节点存在Hash冲突，则尝试获取节点头部链表的锁，获取到则进行设置，获取不到，则阻塞。

篇幅所限，只对关键代码进行了解读，部分代码如：红黑树的查找过程，红黑树和链表的互转均未介绍，感兴趣的可以自己下去解读。同时由于水平有限，文章中难免有疏漏的地方，欢迎批评指正。我们下篇文章见....

参考文章 Java 并发编程的艺术

并发编程之ConcurrentHashMap源码解读-1.8