本文详细探讨了ConcurrentHashMap的实现原理，包括其为何不继承HashMap，两者的相似与不同之处，以及在put和get操作中的线程安全措施。在扩容时，通过转移节点确保线程安全，同时在初始化和数据迁移过程中利用自旋、CAS和锁机制保证并发性能。此外，文章还介绍了其在数组初始化和红黑树操作时的线程安全策略。
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。
716
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
