上一篇文章并发编程之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<K,V>[]，用来存放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<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的流程如下：
- 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<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方法的介绍里，多次提到了扩容。扩容作为一个耗时的操作，多线程扩容如何保证线程安全和兼顾效率的呢？
扩容流程
-
计算步长。具体计算方法是：数组长度/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<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之后的链表是无需遍历和重新构造的。
高低位拆分主要包括以下步骤：
- 循环整个链表，得到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<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 并发编程的艺术
