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

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

  1. 前言
  2. 基本原理
  3. 基础组件
  4. put
  5. 扩容
  6. get
  7. size
  8. 总结

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. 基本原理

  1. 内部持有一个Node<K,V>[],用来存放key,value
    1.1 这个数组的默认长度是16,并且只会在第一次put的时候才会初始化(lazy init)。
  2. 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的值,并且检查是否需要扩容。
  3. get的时候同样通过运算得到应存放的数组下标,然后进行遍历
    3.1 先进行hash扰动,使用hash&(n-1)得到数组索引。
    3.2 取索引对应的数据进行遍历。可能是链表、红黑树,也可能是FWD节点。
  4. 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<K,V>[] table;
要转移到的目标数组,只有扩容的时候非空
private transient volatile Node<K,V>[] 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<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-用来构建TreeBin,红黑树的节点

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;

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

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

 static final class TreeBin<K,V> extends Node<K,V> {
        TreeNode<K,V> root;
        volatile TreeNode<K,V> first;
        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<K,V> extends Node<K,V> {
        final Node<K,V>[] nextTable;
        ForwardingNode(Node<K,V>[] 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<K,V>[] tab = table;;) {
            Node<K,V> 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<K,V>(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<K,V> 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<K,V> pred = e;
                                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) {
                    超过阈值,链表转红黑树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        size+1&检查是否需要扩容
        addCount(1L, binCount);
        return null;
    }

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

  1. hash扰动
  2. 死循环put,直到成功
    2.1 数组未初始化,则进行初始化
    2.2 元素为空,则进行CAS插入
    2.3 元素正在转移,则协助转移
    2.4 存在hash冲突,则锁住头节点,进行插入
  3. 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<K,V>[] initTable() {
        Node<K,V>[] 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<K,V>[] nt = (Node<K,V>[])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<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
    transient volatile Node<K,V>[] table;
    static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }
    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }

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

为什么Node<K,V>[] 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<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
        Node<K,V>[] nextTab; int sc;
       数组不为空&当前节点为FWD节点&转移的目标数组不为空
        if (tab != null && (f instanceof ForwardingNode) &&
            (nextTab = ((ForwardingNode<K,V>)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<K,V> 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<K,V> pred = e;
                                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) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }

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

链表转红黑树

    private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> 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<K,V> hd = null, tl = null;
                        for (Node<K,V> e = b; e != null; e = e.next) {
                            TreeNode<K,V> p =
                                new TreeNode<K,V>(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<K,V>(hd));
                    }
                }
            }
        }
    }

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

       TreeBin(TreeNode<K,V> b) {
            super(TREEBIN, null, null, null);
            this.first = b;
            TreeNode<K,V> r = null;
            for (TreeNode<K,V> x = b, next; x != null; x = next) {
                next = (TreeNode<K,V>)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<K,V> 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<K,V> 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<K,V>[] 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方法的介绍里,多次提到了扩容。扩容作为一个耗时的操作,多线程扩容如何保证线程安全和兼顾效率的呢?

扩容流程

  1. 计算步长。具体计算方法是:数组长度/8/可用核心数,如果得到的数字小于16,则默认为16。
  2. 初始化nextTab和transferIndex。其中nextTab为原数组的两倍,transferIndex为原数组的长度。
  3. 死循环扩容
    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. 数据转移
    4.1 锁住表头,防止转移的时候其它线程往这个节点插入数据
    4.2 如果当前槽位的元素类型是链表,则通过遍历链表的每个元素,通过hash&length,做高低位拆分。为0放低位,否则放高位。低位下标保持不变,高位则为原始下标+n
    4.3 如果当前槽位的元素类型是红黑树,则通过遍历红黑树,按照同样的方式拆分。如果拆分后的树长度<=6,则重新转链表

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


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

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


扩容过程.png

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

 private final void transfer(Node<K,V>[] tab, Node<K,V>[] 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<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 = nextTab;
            transferIndex = n;
        }
        int nextn = nextTab.length;
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        advance标识当前节点是否已完成转移,为true则可以继续进行到下一个节点
        boolean advance = true;
        整个扩容是否已完成
        boolean finishing = false; // to ensure sweep before committing nextTab
        死循环转移
        for (int i = 0, bound = 0;;) {
            Node<K,V> 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<K,V> ln, hn;
                        链表处理扩及
                        if (fh >= 0) {
                            用hashcode&数组长度计算runBit,runBit只有两种结果 0/非0
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            for (Node<K,V> 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<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);
                            }
                            将得到的低位链表插入到新的数组中,低位链表的下标不变
                            setTabAt(nextTab, i, ln);
                            高位链表的下标为:原始下标+原始数组长度
                            setTabAt(nextTab, i + n, hn);
                            完成当前节点转移后,将当前节点设置为FWD占位节点
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            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之后的链表是无需遍历和重新构造的。

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

  1. 循环整个链表,得到runBit和lastRun。
  2. 根据lastRun的值,得到初始ln/hn
  3. 循环整个链表直到lastRun,构建完整ln&hn
  4. 按高低位区分插入不同位置,设置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<K,V>[] tab; Node<K,V> 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 并发编程的艺术

推荐阅读更多精彩内容