上一篇文章并发编程之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中可能存储在链表或者红黑树中。
put流程
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;
}
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中最复杂的地方,因为涉及到多线程扩容,又要兼顾数据安全和效率。
上述扩容过程的详细流程图如下:
源码
清楚了上面的流程,再结合源码来看就相对容易理解一点了。
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号桶的位置有一个链表。
-
高低位拆分
当对索引4对应的链表进行转移的时候,会进行高低位拆分,将其拆分成高位链表和低位链表。
-
扩容后的数组
可以看到,经过高低位拆分后,成功将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变量baseCoun
t,定义了一个volatile CounterCell[]
来实现LongAdder
。 - 每次size++的时候先判断CounterCell[] 是否为空,如果为空,则
尝试利用CAS更新baseCount为baseCount+1
。如果更新成功,则计数成功。 - 如果CounterCell[]不为空,或者更新baseCount失败,尝试
将不同线程的计数请求分配到不同的CounterCell
中,然后利用CAS 更新CounterCell[i]对应的volatile value
。类似LongAdder。
源码
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 并发编程的艺术