1.架构
ConcurrentHashMap的底层数据结构和方法的实现细节与HashMap大体一致,但两者在类结构上却没有任何关联,看ConcurrentHashMap源码,会发现很多方法的代码和HashMap很相似,那就会存在一个问题,为什么不继承HashMap呢?继承的确是个好办法,但尴尬的是,ConcurrentHashMap都是在方法中间进行一些加锁操作,也就是说加锁把方法切割了,继承就很难解决这个问题。
ConcurrentHashMap和HashMap两者的相同之处主要有两点。一是数组、链表结构几乎相同,所以底层对数据结构的操作思路是相同的(是思路相同,底层实现不同)。二是都实现了Map接口,继承了AbstractMap抽象类,所以大多数的方法也都是相同的,HashMap有的方法,ConcurrentHashMap几乎都有,所以当需要从HashMap切换到ConcurrentHashMap时,无需关心两者之间的兼容问题。
不同之处也有两点。一是红黑树结构略有不同,HashMap的红黑树中的节点叫做 TreeNode,TreeNode不仅仅有属性,还维护着红黑树的结构,比如说查找,新增等等。ConcurrentHashMap中红黑树被拆分成两块,TreeNode仅仅维护着属性和查找功能,新增了TreeBin来维护红黑树结构,并负责根节点的加锁和解锁。二是新增ForwardingNode(转移)节点,扩容时会通过该节点来保障线程安全。
2.类注释
- 所有的操作都是线程安全的,在使用时,无需再加锁。
- 多个线程同时进行put、remove等操作时并不会阻塞,可以同时进行,和HashTable不同,HashTable在操作时,会锁住整个Map。
- 迭代过程中,即使Map结构被修改,也不会抛ConcurrentModificationException异常。
- 除了数组 + 链表 + 红黑树的基本结构外,新增了转移节点来保证扩容时的线程安全。
- 提供了很多Stream流式方法,如forEach、search、reduce等。
3.put
ConcurrentHashMap在put方法上的整体思路和HashMap相同,但在线程安全方面写了很多保障的代码,具体源码如下所示。
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
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 (ConcurrentHashMap.Node<K, V>[] tab = table; ; ) {
ConcurrentHashMap.Node<K, V> f;
int n, i, fh;
//如果tab为空,则进行初始化
if (tab == null || (n = tab.length) == 0){
tab = initTable();
//如果当前索引位置没有值,则直接创建
}else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//cas在i位置创建新的元素,当i位置为空,即创建成功,结束for循环,否则继续自旋
if (casTabAt(tab, i, null, new ConcurrentHashMap.Node<K, V>(hash, key, value, null)))
break;
//如果当前槽点是转移节点,表示该槽点正在扩容,就会一直等待扩容完成
//转移节点的hash值是固定的,都是MOVED
}else if ((fh = f.hash) == MOVED){
tab = helpTransfer(tab, f);
}else { //槽点上有值
V oldVal = null;
//锁定当前槽点,其余线程不能操作,保证了线程安全
synchronized (f) {
//这里再次判断i索引位置的数据是否被修改
if (tabAt(tab, i) == f) {
//链表
if (fh >= 0) {
//binCount被赋值的话,说明走到了修改表的过程里
binCount = 1;
for (ConcurrentHashMap.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;
}
ConcurrentHashMap.Node<K, V> pred = e;
//把新增的元素赋值到链表的最后,退出自旋
if ((e = e.next) == null) {
pred.next = new ConcurrentHashMap.Node<K, V>(hash, key, value, null);
break;
}
}
//红黑树,这里没有使用TreeNode,使用的是TreeBin,TreeNode只是红黑树的一个节点
//TreeBin持有红黑树的引用,并且会对其加锁,保证操作是线程安全的
} else if (f instanceof ConcurrentHashMap.TreeBin) {
ConcurrentHashMap.Node<K, V> p;
binCount = 2;
//if条件满足的话,把老的值赋给oldVal
//在putTreeVal方法里,在给红黑树重新着色旋转时,会锁住红黑树的根节点
if ((p = ((ConcurrentHashMap.TreeBin<K, V>) f).putTreeVal(hash, key, value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent){
p.val = value;
}
}
}
}
}
//binCount不为空,并且oldVal有值的情况,说明已经新增成功了
if (binCount != 0) {
//链表是否需要转化成红黑树
if (binCount >= TREEIFY_THRESHOLD){
treeifyBin(tab, i);
}
if (oldVal != null){
return oldVal;
}
//这一步几乎走不到,槽点已经上锁,只有在红黑树或者链表新增失败时,才会走到这里,两者新增都是自旋的,几乎不会失败
break;
}
}
}
//check容器是否需要扩容,如果需要扩容,调用transfer方法扩容,如果已经在扩容中,check有无完成
addCount(1L, binCount);
return null;
}
}
4.get
ConcurrentHashMap获取value时,先获取数组的下标,然后通过判断数组下标的key是否和搜索的key相等,相等的话直接返回,如果下标的槽点是链表或红黑树的话,分别调用相应查找数据的方法,整体思路和HashMap很像,具体源码如下所示。
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
public V get(Object key) {
Node<K, V>[] tab;
Node<K, V> e, p;
int n, eh;
K ek;
//计算hashcode
int h = spread(key.hashCode());
//数组不为空并且当前索引的槽点数据不为空
if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
//槽点第一个值和key相等,直接返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
//如果是红黑树或者转移节点,使用对应的find方法
} 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;
}
}
5.数组初始化时的线程安全
数组初始化时,首先通过自旋来保证一定可以初始化成功,然后通过CAS设置SIZECTL变量的值,来保证同一时刻只能有一个线程对数组进行初始化,CAS成功之后,还会再次判断当前数组是否已经初始化完成,如果已经初始化完成,就不会再次初始化,通过自旋 + CAS + 双重check等手段保证了数组初始化时的线程安全,具体源码如下所示。
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
//初始化tab,通过对sizeCtl的变量赋值来保证数组只能被初始化一次
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
//通过自旋保证初始化成功
while ((tab = table) == null || tab.length == 0) {
//小于0代表有线程正在初始化,释放当前CPU的调度权,重新发起锁的竞争
if ((sc = sizeCtl) < 0){
Thread.yield();
//CAS赋值保证当前只有一个线程在初始化,-1代表当前只有一个线程能初始化
//这种方式保证了数组的初始化的安全性
}else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
//很有可能执行到这里的时候,tab已经不为空了,这里是双重check
if ((tab = table) == null || tab.length == 0) {
//进行初始化
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
}
6.新增槽点值时的线程安全
为了保证线程安全,ConcurrentHashMap做了四处优化,具体如下。
- 通过自旋死循环保证一定可以新增成功。在新增之前,通过for(Node<K,V> [] tab = table;;)这样的死循环来保证新增一定可以成功,一旦新增成功,就可以退出当前死循环,新增失败的话,会重复新增的步骤,直到新增成功为止。
- 当前槽点为空时,通过CAS新增。这里的写法非常严谨,没有在判断槽点为空的情况下直接赋值,因为在判断槽点为空和赋值的瞬间,很有可能槽点已经被其他线程赋值了,所以采用CAS算法,能够保证槽点为空的情况下赋值成功,如果恰好槽点已经被其他线程赋值,当前CAS操作失败,会再次执行for自旋,再走槽点有值的put流程,这里就是自旋 + CAS的结合。
- 当前槽点有值,锁住当前槽点。put时,如果当前槽点有值,就是key的hash冲突的情况,此时槽点上可能是链表或红黑树,通过锁住槽点,来保证同一时刻只会有一个线程能对槽点进行修改。
- 红黑树旋转时,锁住红黑树的根节点,保证同一时刻,当前红黑树只能被一个线程旋转。
通过以上4点,保证了在各种情况下的新增(不考虑扩容的情况下),都是线程安全的,通过自旋 + CAS + 锁三大姿势,实现的很巧妙,值得借鉴。
7.扩容时的线程安全
ConcurrentHashMap的扩容时机和HashMap相同,都是在put方法的最后一步检查是否需要扩容,如果需要则进行扩容,但两者扩容的过程完全不同,ConcurrentHashMap扩容的方法叫做transfer,从put方法的addCount方法进去,就能找到transfer方法,transfer方法的主要思路如下。
首先需要把老数组的值全部拷贝到扩容之后的新数组上,先从数组的队尾开始拷贝。然后拷贝数组的槽点,先把原数组槽点锁住,保证原数组槽点不能操作,成功拷贝到新数组时,再把原数组槽点赋值为转移节点。接下来,如果有新数据正好需要put到此槽点,发现槽点为转移节点就会一直等待,所以在扩容完成之前,该槽点对应的数据是不会发生变化的。最后从数组的尾部拷贝到头部,每拷贝成功一次,就把原数组中的节点设置成转移节点。直到所有数组数据都拷贝到新数组后,直接把新数组整个赋值给数组容器,拷贝完成,具体源码如下所示。
/**
1. 扩容主要分2步,第一步新建新的空数组,第二步移动拷贝每个元素到新数组中去
2. tab为原数组,nextTab为新数组
*/
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
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;
}
//如果新数组为空,则进行初始化,大小为原数组的两倍,n << 1
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n << 1];
nextTab = nt;
} catch (Throwable ex) {
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;
}
//新数组的长度
int nextn = nextTab.length;
//代表转移节点,如果原数组上是转移节点,说明该节点正在被扩容
ForwardingNode<K, V> fwd = new ForwardingNode<K, V>(nextTab);
boolean advance = true;
boolean finishing = false;
//无限自旋,i的值会从原数组的最大值开始,慢慢递减到0
for (int i = 0, bound = 0; ; ) {
Node<K, V> f;
int fh;
while (advance) {
int nextIndex, nextBound;
//结束循环的标志
if (--i >= bound || finishing) {
advance = false;
} else if ((nextIndex = transferIndex) <= 0) {//已经拷贝完成
i = -1;
advance = false;
} else if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {//每次减少i的值
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
//if任意条件满足,说明拷贝结束了
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
//拷贝结束,直接赋值,因为每次拷贝完一个节点,都在原数组上放转移节点,所以拷贝完成的节点的数据一定不会再发生变化
//原数组发现是转移节点,便停止操作,会一直等待转移节点消失之后再进行操作,也就是说数组节点一旦被标记为转移节点,是不会再发生任何变动的,所以不会有任何线程安全的问题
//所以此处直接赋值,没有任何问题
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n;
}
} else if ((f = tabAt(tab, i)) == null){
advance = casTabAt(tab, i, null, fwd);
} else if ((fh = f.hash) == MOVED) {
advance = true; // already processed
} else {
//进行节点的拷贝
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K, V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
Node<K, V> lastRun = f;
//如果节点只有一个数据,直接拷贝,如果是链表,循环多次组成链表拷贝
for (Node<K, V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
} else {
hn = lastRun;
ln = null;
}
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);
//在老数组位置上放上ForwardingNode节点
//put时,发现是ForwardingNode节点,就不会再更改这个节点的数据
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);
//在老数组位置上放上ForwardingNode节点
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
}
扩容方法还是很有意思的,通过在原数组上设置转移节点,put时碰到转移节点就会等待,扩容成功之后才能put,这保证了整个扩容过程中肯定是线程安全的,因为数组的槽点一旦被设置成转移节点,在没有扩容完成之前,是无法进行操作的。扩容中的关键点,就是如何保证是线程安全的,总结如下。
- 拷贝槽点时,会把原数组的槽点锁住。
- 拷贝成功之后,会把原数组的槽点设置成转移节点,这样如果有数据需要put到该节点时,发现该槽点是转移节点,会一直等待,直到扩容成功之后,才能继续put,可以参考put方法中helpTransfer方法。
- 从尾到头进行拷贝,拷贝成功就把原数组的槽点设置成转移节点。等扩容拷贝都完成之后,直接把新数组的值赋值给数组容器,之前等待put的数据才能继续put。