## 16 ConcurrentHashMap 源码解析和设计思路
## 引导语
当我们碰到线程不安全场景下,需要使用 Map 的时候,我们第一个想到的 API 估计就是 ConcurrentHashMap,ConcurrentHashMap 内部封装了锁和各种数据结构来保证访问 Map 是线程安全的,接下来我们一一来看下,和 HashMap 相比,多了哪些数据结构,又是如何保证线程安全的。
### 1 类注释
我们从类注释上大概可以得到如下信息:
1. 所有的操作都是线程安全的,我们在使用时,无需再加锁;
2. 多个线程同时进行 put、remove 等操作时并不会阻塞,可以同时进行,和 HashTable 不同,HashTable 在操作时,会锁住整个 Map;
3. 迭代过程中,即使 Map 结构被修改,也不会抛 ConcurrentModificationException 异常;
4. 除了数组 + 链表 + 红黑树的基本结构外,新增了转移节点,是为了保证扩容时的线程安全的节点;
5. 提供了很多 Stream 流式方法,比如说:forEach、search、reduce 等等。
从类注释中,我们可以看出 ConcurrentHashMap 和 HashMap 相比,新增了转移节点的数据结构,至于底层如何实现线程安全,转移节点的具体细节,暂且看不出来,接下来我们细看源码。
### 2 结构
虽然 ConcurrentHashMap 的底层数据结构,和方法的实现细节和 HashMap 大体一致,但两者在类结构上却没有任何关联,我们看下 ConcurrentHashMap 的类图:
![](https://img.kancloud.cn/21/96/2196a864ded7967067870a07c811511d_467x199.jpg)
看 ConcurrentHashMap 源码,我们会发现很多方法和代码和 HashMap 很相似,有的同学可能会问,为什么不继承 HashMap 呢?继承的确是个好办法,但尴尬的是,ConcurrentHashMap 都是在方法中间进行一些加锁操作,也就是说加锁把方法切割了,继承就很难解决这个问题。
ConcurrentHashMap 和 HashMap 两者的相同之处:
1. 数组、链表结构几乎相同,所以底层对数据结构的操作思路是相同的(只是思路相同,底层实现不同);
2. 都实现了 Map 接口,继承了 AbstractMap 抽象类,所以大多数的方法也都是相同的,HashMap 有的方法,ConcurrentHashMap 几乎都有,所以当我们需要从 HashMap 切换到 ConcurrentHashMap 时,无需关心两者之间的兼容问题。
不同之处:
1. 红黑树结构略有不同,HashMap 的红黑树中的节点叫做 TreeNode,TreeNode 不仅仅有属性,还维护着红黑树的结构,比如说查找,新增等等;ConcurrentHashMap 中红黑树被拆
分成两块,
TreeNode 仅仅维护的属性和查找功能,新增了 TreeBin,来维护红黑树结构,并负责根节点的加锁和解锁; 2.
新增 ForwardingNode (转移)节点,扩容的时候会使用到,通过使用该节点,来保证扩容时的线程安全。
### 3 put
ConcurrentHashMap 在 put 方法上的整体思路和 HashMap 相同,但在线程安全方面写了很多保障的代码,我们先来看下大体思路:
1. 如果数组为空,初始化,初始化完成之后,走 2;
2. 计算当前槽点有没有值,没有值的话,cas 创建,失败继续自旋(for 死循环),直到成功,槽点有值的话,走 3;
3. 如果槽点是转移节点(正在扩容),就会一直自旋等待扩容完成之后再新增,不是转移节点走 4;
4. 槽点有值的,先锁定当前槽点,保证其余线程不能操作,如果是链表,新增值到链表的尾部,如果是红黑树,使用红黑树新增的方法新增;
5. 新增完成之后 check 需不需要扩容,需要的话去扩容。
具体源码如下:
```
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;
//table是空的,进行初始化 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 Node<K,V>(hash, key, value, null))) break; // no lock when adding to empty bin } //如果当前槽点是转移节点,表示该槽点正在扩容,就会一直等待扩容完成 //转移节点的 hash 值是固定的,都是 MOVED else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); //槽点上有值的 else { V oldVal = null; //锁定当前槽点,其余线程不能操作,保证了安全 synchronized (f) { //这里再次判断 i 索引位置的数据没有被修改 //binCount 被赋值的话,说明走到了修改表的过程里面 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; } } } //红黑树,这里没有使用 TreeNode,使用的是 TreeBin,TreeNode 只是红黑树的一个节点 //TreeBin 持有红黑树的引用,并且会对其加锁,保证其操作的线程安全 else if (f instanceof TreeBin) { Node<K,V> p; binCount = 2; //满足if的话,把老的值给oldVal //在putTreeVal方法里面,在给红黑树重新着色旋转的时候 //会锁住红黑树的根节点 if ((p = ((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; }
```
源码中都有非常详细的注释,就不解释了,我们重点说一下,ConcurrentHashMap 在 put 过程中,采用了哪些手段来保证线程安全。
#### 3.1 数组初始化时的线程安全
数组初始化时,首先通过自旋来保证一定可以初始化成功,然后通过 CAS 设置 SIZECTL 变量的值,来保证同一时刻只能有一个线程对数组进行初始化,CAS 成功之后,还会再次判断当前数组是否已经初始化完成,如果已经初始化完成,就不会再次初始化,通过自旋 + CAS + 双重 check 等手段保证了数组初始化时的线程安全,源码如下:
```
//初始化 table,通过对 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(); // lost initialization race; just spin // CAS 赋值保证当前只有一个线程在初始化,-1 代表当前只有一个线程能初始化 // 保证了数组的初始化的安全性 else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { // 很有可能执行到这里的时候,table 已经不为空了,这里是双重 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; }
```
3.2 新增槽点值时的线程安全
此时为了保证线程安全,做了四处优化:
1. 通过自旋死循环保证一定可以新增成功。
在新增之前,通过 for (Node[] tab = table;;) 这样的死循环来保证新增一定可以成功,一旦新增成功,就可以退出当前死循环,新增失败的话,会重复新增的步骤,直到新增成功为止。
2. 当前槽点为空时,通过 CAS 新增。
Java 这里的写法非常严谨,没有在判断槽点为空的情况下直接赋值,因为在判断槽点为空和赋值的瞬间,很有可能槽点已经被其他线程赋值了,所以我们采用 CAS 算法,能够保证槽点为空的情况下赋值成功,如果恰好槽点已经被其他线程赋值,当前 CAS 操作失败,会再次执行 for 自旋,再走槽点有值的 put 流程,这里就是自旋 + CAS 的结合。
3. 当前槽点有值,锁住当前槽点。
put 时,如果当前槽点有值,就是 key 的 hash 冲突的情况,此时槽点上可能是链表或红黑树,我们通过锁住槽点,来保证同一时刻只会有一个线程能对槽点进行修改,截图如下:
![](https://img.kancloud.cn/c9/43/c943e333ca41013e9f1a1a4a5a802752_413x67.jpg)
4. 红黑树旋转时,锁住红黑树的根节点,保证同一时刻,当前红黑树只能被一个线程旋转,代码截图如下:
![](https://img.kancloud.cn/64/64/6464d713fdb5414c2c0d88673b6f74d8_584x440.jpg)
通过以上 4 点,保证了在各种情况下的新增(不考虑扩容的情况下),都是线程安全的,通过自旋 + CAS + 锁三大姿势,实现的很巧妙,值得我们借鉴。
#### 3.3 扩容时的线程安全
ConcurrentHashMap 的扩容时机和 HashMap 相同,都是在 put 方法的最后一步检查是否需要扩容,如果需要则进行扩容,但两者扩容的过程完全不同,ConcurrentHashMap 扩容的方法叫做 transfer,从 put 方法的 addCount 方法进去,就能找到 transfer 方法,transfer 方法的主要思路是:
1. 首先需要把老数组的值全部拷贝到扩容之后的新数组上,先从数组的队尾开始拷贝;
2. 拷贝数组的槽点时,先把原数组槽点锁住,保证原数组槽点不能操作,成功拷贝到新数组时,把原数组槽点赋值为转移节点;
3. 这时如果有新数据正好需要 put 到此槽点时,发现槽点为转移节点,就会一直等待,所以在扩容完成之前,该槽点对应的数据是不会发生变化的;
4. 从数组的尾部拷贝到头部,每拷贝成功一次,就把原数组中的节点设置成转移节点;
5. 直到所有数组数据都拷贝到新数组时,直接把新数组整个赋值给数组容器,拷贝完成。
关键源码如下:
```
// 扩容主要分 2 步,第一新建新的空数组,第二移动拷贝每个元素到新数组中去 // tab:原数组,nextTab:新数组 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 // 如果新数组为空,初始化,大小为原数组的两倍,n << 1 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); boolean advance = true; boolean finishing = false; // to ensure sweep before committing nextTab // 无限自旋,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; } // 每次减少 i 的值 else if (U.compareAndSwapInt (this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) { 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; // recheck before commit } } 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) { // 红黑树的拷贝工作,同 HashMap 的内容,代码忽略 …………
// 在老数组位置上放上 ForwardingNode 节点 setTabAt(tab, i, fwd); advance = true; } } } } } }
```
扩容中的关键点,就是如何保证是线程安全的,小结有如下几点:
1. 拷贝槽点时,会把原数组的槽点锁住;
2. 拷贝成功之后,会把原数组的槽点设置成转移节点,这样如果有数据需要 put 到该节点时,发现该槽点是转移节点,会一直等待,直到扩容成功之后,才能继续 put,可以参考 put 方法中的 helpTransfer 方法;
3. 从尾到头进行拷贝,拷贝成功就把原数组的槽点设置成转移节点。
4. 等扩容拷贝都完成之后,直接把新数组的值赋值给数组容器,之前等待 put 的数据才能继续 put。
扩容方法还是很有意思的,通过在原数组上设置转移节点,put 时碰到转移节点时会等待扩容成功之后才能 put 的策略,来保证了整个扩容过程中肯定是线程安全的,因为数组的槽点一旦被设置成转移节点,在没有扩容完成之前,是无法进行操作的。
### 4 get
ConcurrentHashMap 读的话,就比较简单,先获取数组的下标,然后通过判断数组下标的 key 是否和我们的 key 相等,相等的话直接返回,如果下标的槽点是链表或红黑树的话,分别调用相应的查找数据的方法,整体思路和 HashMap 很像,源码如下:
```
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()); //不是空的数组 && 并且当前索引的槽点数据不是空的 //否则该key对应的值不存在,返回null 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 总结
本文摘取 ConcurrentHashMap 两个核心的方法讲解了一下,特别是 put 方法,采取了很多手段来保证了线程安全,是平时面试时的重中之重,大家可以尝试 debug 来调试一下源码,其他方法感兴趣的话,可以尝试去 GitHub 上去查看源码。
- 前言
- 第1章 基础
- 01 开篇词:为什么学习本专栏
- 02 String、Long 源码解析和面试题
- 03 Java 常用关键字理解
- 04 Arrays、Collections、Objects 常用方法源码解析
- 第2章 集合
- 05 ArrayList 源码解析和设计思路
- 06 LinkedList 源码解析
- 07 List 源码会问哪些面试题
- 08 HashMap 源码解析
- 09 TreeMap 和 LinkedHashMap 核心源码解析
- 10 Map源码会问哪些面试题
- 11 HashSet、TreeSet 源码解析
- 12 彰显细节:看集合源码对我们实际工作的帮助和应用
- 13 差异对比:集合在 Java 7 和 8 有何不同和改进
- 14 简化工作:Guava Lists Maps 实际工作运用和源码
- 第3章 并发集合类
- 15 CopyOnWriteArrayList 源码解析和设计思路
- 16 ConcurrentHashMap 源码解析和设计思路
- 17 并发 List、Map源码面试题
- 18 场景集合:并发 List、Map的应用场景
- 第4章 队列
- 19 LinkedBlockingQueue 源码解析
- 20 SynchronousQueue 源码解析
- 21 DelayQueue 源码解析
- 22 ArrayBlockingQueue 源码解析
- 23 队列在源码方面的面试题
- 24 举一反三:队列在 Java 其它源码中的应用
- 25 整体设计:队列设计思想、工作中使用场景
- 26 惊叹面试官:由浅入深手写队列
- 第5章 线程
- 27 Thread 源码解析
- 28 Future、ExecutorService 源码解析
- 29 押宝线程源码面试题
- 第6章 锁
- 30 AbstractQueuedSynchronizer 源码解析(上)
- 31 AbstractQueuedSynchronizer 源码解析(下)
- 32 ReentrantLock 源码解析
- 33 CountDownLatch、Atomic 等其它源码解析
- 34 只求问倒:连环相扣系列锁面试题
- 35 经验总结:各种锁在工作中使用场景和细节
- 36 从容不迫:重写锁的设计结构和细节
- 第7章 线程池
- 37 ThreadPoolExecutor 源码解析
- 38 线程池源码面试题
- 39 经验总结:不同场景,如何使用线程池
- 40 打动面试官:线程池流程编排中的运用实战
- 第8章 Lambda 流
- 41 突破难点:如何看 Lambda 源码
- 42 常用的 Lambda 表达式使用场景解析和应用
- 第9章 其他
- 43 ThreadLocal 源码解析
- 44 场景实战:ThreadLocal 在上下文传值场景下的实践
- 45 Socket 源码及面试题
- 46 ServerSocket 源码及面试题
- 47 工作实战:Socket 结合线程池的使用
- 第10章 专栏总结
- 48 一起看过的 Java 源码和面试真题