文章目录
- 1.Java 7 版本的 ConcurrentHashMap
- 2.Java 8 版本的 ConcurrentHashMap
- 3.分析 Java 8 版本的 ConcurrentHashMap 的重要源码
- 3.1.Node 节点
- 3.2.put 方法源码分析
- 3.3.get 方法源码分析
- 4.对比 Java7 和 Java8 的异同和优缺点
- 4.1.并发度
- 4.2.保证并发安全的原理
- 4.3.遇到 Hash 碰撞
- 4.4.查询时间复杂度
1.Java 7 版本的 ConcurrentHashMap
我们首先来看一下 Java 7 版本中的 ConcurrentHashMap
的结构示意图:
从图中我们可以看出,在 ConcurrentHashMap
内部进行了 Segment
分段, Segment
继承了ReentrantLock
,可以理解为一把锁,各个 Segment
之间都是相互独立上锁的,互不影响。相比于之前的Hashtable
每次操作都需要把整个对象锁住而言,大大提高了并发效率。因为它的锁与锁之间是独立的,而不是整个对象只有一把锁。
每个 Segment
的底层数据结构与 HashMap
类似,仍然是数组和链表组成的拉链法结构。默认有 0~15共 16
个 Segment
,所以最多可以同时支持 16
个线程并发操作(操作分别分布在不同的 Segment
上)。 16
这个默认值可以在初始化的时候设置为其他值,但是一旦确认初始化以后,是不可以扩容 的。
2.Java 8 版本的 ConcurrentHashMap
在 Java 8 中的示意图:
图中的节点有三种类型。
- 第一种是最简单的,空着的位置代表当前还没有元素来填充。
- 第二种就是和
HashMap
非常类似的拉链法结构,在每一个槽中会首先填入第一个节点,但是后续 如果计算出相同的Hash
值,就用链表的形式往后进行延伸。 - 第三种结构就是红黑树结构,这是 Java 7 的
ConcurrentHashMap
中所没有的结构。
当第二种情况的链表长度大于某一个阈值(默认为 8),且同时满足一定的容量要求的时候,ConcurrentHashMap
便会把这个链表从链表的形式转化为红黑树的形式,目的是进一步提高它的查找性能。
红黑树是每个节点都带有颜色属性的二叉查找树,颜色为红色或黑色,是一种平衡二叉查找树,查找效率高,会自动平衡,防止极端不平衡从而影响查找效率的情况发生。由于自平衡的特点,即左右子树高度几乎一致,所以其查找性能近似于二分查找,时间复杂度是O(log(n))
级别;反观链表,它的时间复杂度就不一样了,如果发生了最坏的情况,可能需要遍历整个链表才能找到目标元素,时间复杂度为 O(n)
,远远大于红黑树的 O(log(n)),尤其是在节点越来越多的情况下,O(log(n))
体现出的优势会更加明显。
红黑树的一些其他特点:
- 每个节点要么是红色,要么是黑色,但根节点永远是黑色的。
- 红色节点不能连续,也就是说,红色节点的子和父都不能是红色的。
- 从任一节点到其每个叶子节点的路径都包含相同数量的黑色节点。
正是由于这些规则和要求的限制,红黑树保证了较高的查找效率,好处就是避免在极端的情况下冲突链表变得很长,在查询的时 候,效率会非常慢。而红黑树具有自平衡的特点,所以,即便是极端情况下,也可以保证查询效率在O(log(n))
。
3.分析 Java 8 版本的 ConcurrentHashMap 的重要源码
由于 Java 7 版本已经过时了,所以我们把重点放在 Java 8 版本的源码分析上。
3.1.Node 节点
我们看看最基础的内部存储结构 Node,这就是一个一个的节点,如这段代码所示:
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
里面是key-value
的形式,并且把 value
用 volatile
修饰,以便保证可见性,同时内部还有一个指向下一个节点的 next
指针,方便产生链表结构。
下面我们看两个最重要、最核心的方法。
3.2.put 方法源码分析
put 方法的核心是 putVal 方法,为了方便阅读,我把重要步骤的解读用注释的形式补充在下面的源码中。
final V putVal(K key, V value, boolean onlyIfAbsent) {// 检查是否有空键或值if (key == null || value == null) throw new NullPointerException();// 计算哈希并进行扩散以避免聚集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();else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// 如果桶为空,请尝试原子性地添加新节点if (casTabAt(tab, i, null, new Node<K, V>(hash, key, value, null)))break; // 添加到空桶时不需要锁定} else if ((fh = f.hash) == MOVED)// 如果桶正在转移中,请协助进行转移tab = helpTransfer(tab, f);else {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;}}}// 更新地图中元素的计数addCount(1L, binCount);return null;
}
以下是代码的主要功能和步骤解释:
- 参数检查: 首先,代码检查传入的键和值是否为null,如果是,则抛出
NullPointerException
。 - 计算哈希: 使用键的哈希码,并通过
spread
方法对哈希码进行扩散,以减少哈希冲突的可能性。 - 循环处理: 进入一个无限循环,用于处理可能的哈希冲突和表的初始化。
- 初始化表: 如果哈希表为null或长度为0,则通过调用
initTable
方法初始化哈希表。 - 处理空桶: 如果计算得到的桶是空的,则尝试使用CAS(Compare and Swap)原子操作添加新的
Node
节点到该桶中,如果成功则退出循环。 - 处理转移中的桶: 如果当前桶的状态是MOVED(正在进行桶的迁移操作),则调用
helpTransfer
方法协助进行桶的迁移。 - 处理非空桶: 如果桶非空,说明存在哈希冲突,根据桶的类型(链表或树)采取不同的处理方式。
- 如果桶中是链表(
fh >= 0
),则使用同步块在链表中查找键值对。如果找到了相同的键,更新其值,否则将新的Node
节点添加到链表中。 - 如果桶中是树(
f instanceof TreeBin
),则调用putTreeVal
方法在树中插入键值对。
- 更新计数: 最后,根据实际添加的节点数更新哈希表中元素的计数。
- 返回值: 如果在添加操作中替换了已存在的值,返回被替换的旧值,否则返回null。
3.3.get 方法源码分析
get 方法比较简单,我们同样用源码注释的方式来分析一下:
public V get(Object key) {// 定义局部变量Node<K, V>[] tab;Node<K, V> e, p;int n, eh;K ek;// 计算扩散后的哈希值int h = spread(key.hashCode());// 检查哈希表是否已初始化if ((tab = table) != null && (n = tab.length) > 0 &&(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; // 返回找到的值}}// 未找到匹配的键,返回nullreturn null;
}
- 计算哈希: 计算传入键的哈希值,并通过spread方法进行扩散。
- 检查表和桶: 检查哈希表是否已经初始化,以及哈希桶中是否存在节点。
- 处理第一个节点: 检查第一个节点是否匹配,如果匹配则返回对应的值。
- 处理树结构: 如果哈希桶中是树结构,则调用find方法查找匹配的键值对。
- 遍历链表: 在链表中遍历查找匹配的键值对,如果找到则返回对应的值。
- 未找到匹配: 如果遍历完仍未找到匹配的键,则返回null。
4.对比 Java7 和 Java8 的异同和优缺点
数据结构
Java 7 采用 Segment 分段锁来实现,而 Java 8 中的 ConcurrentHashMap 使用数组 + 链表 + 红黑树。
4.1.并发度
Java 7 中,每个 Segment
独立加锁,最大并发个数就是 Segment
的个数,默认是 16
。
Java 8 中,锁粒度更细,理想情况下 table
数组元素的个数(也就是数组长度)就是其支持并
发的最大个数,并发度比之前有提高。
4.2.保证并发安全的原理
Java 7 采用 Segment
分段锁来保证安全,而 Segment
是继承自 ReentrantLock
。
Java 8 中放弃了 Segment
的设计,采用 Node+CAS+synchronized
保证线程安全。
4.3.遇到 Hash 碰撞
Java 7 在 Hash 冲突时,会使用拉链法,也就是链表的形式。
Java 8 先使用拉链法,在链表长度超过一定阈值时,将链表转换为红黑树,来提高查找效率。
4.4.查询时间复杂度
Java 7 遍历链表的时间复杂度是O(n)
,n 为链表长度。
Java 8 如果变成遍历红黑树,那么时间复杂度降低为 O(log(n))
,n 为树的节点个数。