Java-HashMap和ConcurrentHashMap的区别
在 Java 8中， HashMap和ConcurrentHashMap都经历了一些重要的改进，使得它们 在性能和线程安全性方面有了 显著的差异。
一、关键区别
1.数据结构
-
HashMap (JDK 8):
1.8之前的
1.8后
数组 + 链表 + 红黑树：Java 8中的HashMap引入了红黑树来优化链表过长的情况。当链表长度超过8时（默认设置），链表会被转换成红黑树，以减少查找时间复杂度，从O(n)降低到O(log n)。这一改变主要目的是提高在哈希冲突较多情况下的性能。 -
ConcurrentHashMap (JDK 8):
1.7中
1.8中
数组 + 链表 + 红黑树：类似于HashMap，ConcurrentHashMap在Java 8中也引入了红黑树来优化性能。但是，ConcurrentHashMap的内部结构更为复杂，它不再使用分段锁（Segment），而是采用CAS（Compare and Swap）操作加上一些其他原子操作和少量的synchronized关键字来实现更细粒度的锁，这大大提升了并发性能。
2.线程安全
- HashMap: 不是线程安全的。在多线程环境下，如果没有外部同步，直接使用HashMap可能会导致数据不一致的问题。
- ConcurrentHashMap: 是线程安全的。它通过使用CAS算法和synchronized块（只在最小必要时锁定），实现了对部分桶的加锁，而不是像早期版本那样对整个容器加锁，从而在高并发环境下提供了更好的性能。
3.性能
- HashMap: 单线程环境下性能优秀，但在多线程环境下没有提供安全保障，可能导致数据损坏。
- ConcurrentHashMap: 在多线程环境下性能优越，因为它能更好地控制锁的范围，减少线程之间的竞争，同时在单线程访问时也能保持良好的性能。
4.扩容机制
- HashMap: 在Java 8中，HashMap的扩容仍然是一个相对重量级的操作，虽然它在插入新元素时采用了更高效的尾插法来避免循环链表问题，但扩容时仍需重新分配桶并复制元素。
- ConcurrentHashMap: 其扩容过程更加精细且并发友好，通过多个线程同时参与扩容操作，进一步提高了效率。
二、源码简析
1.并发控制机制
HashMap (简单无锁，非线程安全)
// HashMap的get方法非常简单，直接访问指定位置的桶
V get(Object key) {
Node<K,V> e; // 用于存放找到的节点
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
// 内部查找节点的方法
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 首先检查第一个节点是否即为目标节点
if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 如果第一个节点不是，则沿着链表或树结构继续查找
if ((e = first.next) != null) {
// ...遍历逻辑省略，查找匹配的节点...
}
}
return null;
}
注: HashMap的get操作没有内置的线程安全措施，任何并发修改都可能引起不可预测的行为。它假设在外部进行了同步处理，或在单线程环境下使用。
ConcurrentHashMap (高级并发控制)
/**
* 返回与指定键关联的值，如果此映射中不存在该键的映射，则返回{@code null}。
*
* @param key 要查询的键
* @return 与键关联的值，如果没有则为{@code null}
*/
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) {
ek = e.key; // 保存键引用以供比较
if ((ek == key) || (ek != null && key.equals(ek))) // 键相等
return e.val; // 返回值
}
// 特殊处理：eh < 0 表示可能遇到了ForwardingNode（正在进行resize或其它结构调整）
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null; // 在ForwardingNode中查找键
// 未在首节点找到，遍历链表或树查找
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek)))) {
return e.val; // 找到匹配的键，返回其值
}
}
}
// 未找到匹配项，返回null
return null;
}
通过无锁读取提高并发读性能。它首先计算键的哈希值并定位到桶，然后直接访问桶的第一个节点，无需加锁。如果第一个节点匹配，则直接返回其值。否则，它会遍历桶内的链表或树结构，查找匹配的节点。这种方法在高并发环境下能够显著提升读取性能，因为读操作不需要等待写锁，减少了线程间的竞争。
/**
* 将指定的键与值关联到此映射表中。
* 键和值都不能为null。
*
* <p>可以通过使用与原始键相等的键调用{@code get}方法来检索该值。
*
* @param key 要与此指定值关联的键
* @param value 要与指定键关联的值
* @return 与{@code key}先前关联的值，如果没有映射则为{@code null}
* @throws NullPointerException 如果指定的键或值为null
*/
public V put(K key, V value) {
return putVal(key, value, false);
}
/**
* 实现put和putIfAbsent方法的内部逻辑。
*
* @param key 要插入的键
* @param value 要插入的值
* @param onlyIfAbsent 如果为true且键已存在，则不更新值
* @return 键的旧值，如果没有则为null
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 检查键和值是否为null
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) {
// 使用CAS尝试将新节点放入空桶
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) { // 锁定桶头节点或树节点
// 再次检查桶状态，防止A-B-A问题
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; // 在某些情况下可能未找到旧值
}
putVal 方法是实现 put 和 putIfAbsent 功能的核心逻辑，它负责在 ConcurrentHashMap 中插入或更新键值对。以下是该方法的主要行为和结论概述：
-
键值验证：确保传入的键和值都不为 null，违反此规则将抛出 NullPointerException。
-
哈希与索引计算：通过对键的哈希码应用扰动函数计算得到最终哈希值，并据此确定桶的索引。
-
表初始化与扩容处理：
若表尚未初始化，通过 initTable 进行初始化。
若当前桶正在被转移（因为表正在扩容），则帮助完成转移操作。 -
无锁插入尝试：当目标桶为空时，尝试使用 CAS 操作直接插入新节点，以避免加锁开销。
-
加锁与冲突处理：
对于非空桶，根据头节点类型（链表或树）加锁处理。
遍历桶内链表或在树中搜索匹配的键。
若键已存在，则根据 onlyIfAbsent 参数决定是否更新值。
若键不存在，则插入新节点至链表尾部或树的适当位置。 -
树化阈值检查：当桶内节点数量达到 TREEIFY_THRESHOLD 时，将链表转换为红黑树以优化性能。
-
计数与维护：插入成功后，调用 addCount 方法更新元素数量，并可能触发进一步的扩容判断。
-
返回结果：若键已存在，则返回旧值；否则，在某些情况下可能返回 null。
2.数据结构转换：链表转红黑树
- HashMap
当链表长度达到阈值时，HashMap会尝试将链表转换为红黑树。
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 检查是否需要先扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
// 将链表转换为红黑树
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null); // 转换节点类型
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
// 将红黑树根节点设置回桶中
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
- ConcurrentHashMap
/**
* 将给定索引处桶中的所有链表节点转换为树形节点，除非表太小，
* 在这种情况下会先进行扩容操作。
*/
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; // 指向当前桶的第一个节点
int n, sc; // 分别表示表的长度和树化过程中记录的节点数量
// 确保表不为空
if (tab != null) {
// 检查表容量是否小于最小树化容量，若小于则先尝试扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1); // 尝试将表容量加倍
// 检查桶内有有效节点且不是正在转移的 forwarding node
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) { // 对桶头节点加锁，保护转换过程
// 再次检查桶头是否未改变，防止并发修改
if (tabAt(tab, index) == b) {
// 初始化树的头节点和尾节点
TreeNode<K,V> hd = null, tl = null;
// 遍历桶内链表，将每个节点转换为TreeNode
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p =
new TreeNode<K,V>(e.hash, e.key, e.val, null, null);
// 构建TreeNode的双向链表结构
if ((p.prev = tl) == null)
hd = p; // 设置头节点
else
tl.next = p;
tl = p; // 移动尾节点指针
}
// 将桶设置为新的TreeBin，完成树化
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
它负责在ConcurrentHashMap的桶中将链表转换为红黑树结构，以提高在哈希冲突较多情况下的查找效率。此方法首先检查表容量是否满足树化的最小要求，然后遍历桶内链表，将每个节点转换为TreeNode对象，并构建这些树节点的双向链表结构，最后将桶的头节点替换为一个TreeBin实例，完成树化过程。在整个转换过程中，通过加锁保证了操作的线程安全性。
static final class TreeBin<K,V> extends Node<K,V>的内部类TreeBin
/**
* 使用以节点 `b` 为首的初始节点集创建一个二叉树节点容器。
* 此构造方法负责将一系列已排序的节点（通常源自链表）构造成红黑树结构。
*
* @param b 初始节点集合的头节点，用于构建红黑树。
*/
TreeBin(TreeNode<K,V> b) {
// 调用父类构造器进行初始化，设置TREEBIN标记以及其它属性为null。
super(TREEBIN, null, null, null);
// 保存传入的头节点到first字段。
this.first = b;
// 初始化红黑树的根节点为null。
TreeNode<K,V> r = null;
// 遍历链表中的每个节点。
for (TreeNode<K,V> x = b, next; x != null; x = next) {
// 将当前节点的下一个节点暂存至next。
next = (TreeNode<K,V>)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<K,V> 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)
// 键不可比较，则使用tie-break规则。
dir = tieBreakOrder(k, pk);
else
// 可比较，则直接比较结果作为方向。
dir = compareComparables(kc, k, pk);
}
// 记录当前父节点。
TreeNode<K,V> xp = p;
// 按照dir方向移动至下一个节点，若为空则插入当前节点。
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);
}
- 它接收一个头节点b，遍历以其为首的节点集合，将这些节点逐个插入到一个新的红黑树结构中。过程中，代码不仅重新组织了节点间的链接关系（父母、左右子节点），还通过平衡插节点是黑色；任意节点到其每个叶子节点的所有路径上包含相同数量的黑色节点；且对于每个红色节点，其两个子节点都是黑色的）。通过这种方式，该构造函数保证了转换后的红黑树维持了良好的搜索性能特性，即最坏情况下的时间复杂度为O(log n)。
- 在遍历链表的过程中，代码首先清空每个节点的左右子节点信息，这是因为这些节点之前作为链表的一部分，没有树结构的概念。然后，通过比较节点的哈希值及键值（如果哈希值相同）来确定新节点在树中的插入位置，这一过程体现了红黑树的排序特性。当遇到相等哈希值的情况时，代码还会尝试利用键的自然顺序或者自定义比较器来进一步区分，确保键的唯一性和有序性。
- 特别地，代码中还包括了一个平衡调整的过程，通过balanceInsertion方法在插入新节点后对树进行必要的旋转和重新着色操作，以维护红黑树的平衡状态。这是确保树操作效率的关键步骤，避免了因连续插入导致树形态退化成链式结构的可能性。
- 最后，通过断言assert checkInvariants(root);来验证构建完成的红黑树是否满足红黑树的基本不变量，这是一种调试辅助手段，用于在开发和测试阶段捕捉可能的逻辑错误，确保数据结构的正确性。在生产环境中，断言的启用与否通常取决于JVM的启动参数配置。
3.扩容机制
触发hashMap和concurentHashMap扩容机制的条件
HashMap 扩容条件
- 加载因子（Load Factor）：HashMap 默认的加载因子为 0.75。这意味着当 HashMap 中的元素数量达到其容量的 75% 时，HashMap 会自动进行扩容操作。这是为了防止哈希冲突过于频繁，影响性能。
- 容量（Capacity）：扩容时，HashMap 会创建一个新的更大的数组，并将原有数组中的元素重新分配到新数组中。扩容后的容量通常是原容量的两倍（例如，从 16 扩展到 32）。
ConcurrentHashMap 扩容条件
- 段（Segment）或桶（Bucket）级别扩容：在 Java 8 之前的版本中，ConcurrentHashMap 是由多个 Segment 组成的分段锁结构。每个 Segment 相当于一个小的 HashMap，有各自的扩容机制。当某个 Segment 中的元素数量达到其阈值时，会单独对该 Segment 进行扩容。而在 Java 8 及以后版本中，虽然去除了 Segment，但扩容逻辑类似，关注的是桶（Bucket）级别的增长。
- 全局容量与负载：整体上，ConcurrentHashMap 也会监控其全局的元素数量与容量的比例，当总体元素数量达到全局阈值时，会触发整体的扩容操作。默认的加载因子也是 0.75，意味着当表中的元素数量达到总容量的 75% 时，会进行扩容。
- 并发控制：ConcurrentHashMap 在扩容时采用了细粒度的锁机制，确保扩容操作能与读写操作并发执行，减少阻塞。扩容时，不是一次性复制所有桶，而是逐步将桶从旧数组迁移到新数组，这个过程中仍然允许其他线程的读写操作。
总的来说，HashMap 和 ConcurrentHashMap 都是在元素数量达到一定比例（默认为 75%）时触发扩容，但 ConcurrentHashMap 通过更精细的并发控制机制，在扩容的同时能保持较高的并发性能。
HashMap
/**
* 初始化或加倍哈希表容量。如果原表为空，则按照阈值字段保存的初始容量目标分配空间。
* 否则，由于采用2的幂次扩展方式，来自每个桶的元素必须保持索引不变，
* 或者在新表中以2的幂次偏移量移动。
*
* @return 新的哈希表数组
*/
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // 保存旧的哈希表引用
int oldCap = (oldTab == null) ? 0 : oldTab.length; // 获取旧容量
int oldThr = threshold; // 保存旧的扩容阈值
int newCap, newThr = 0; // 初始化新容量和新阈值
// 如果旧容量大于0
if (oldCap > 0) {
// 如果旧容量已达到最大，设置阈值为最大整数并返回原表
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 否则，如果可以扩大两倍且旧容量至少为默认初始容量，则翻倍容量和阈值
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 阈值也翻倍
}
// 如果旧阈值大于0，说明初始容量被放在了阈值字段里
else if (oldThr > 0)
newCap = oldThr;
// 如果旧阈值为0，使用默认初始容量和加载因子计算新容量和新阈值
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 如果新阈值未设置（仍为0），根据新容量和加载因子计算新阈值
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 设置新的扩容阈值
threshold = newThr;
// 创建新容量大小的新哈希表数组
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 将新表赋值给table引用
table = newTab;
// 如果旧表不为空，开始转移数据
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e; // 当前桶的头节点
// 遍历桶中的节点
if ((e = oldTab[j]) != null) {
// 清除旧桶引用，准备重用节点
oldTab[j] = null;
// 单个节点直接迁移
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 如果是树节点，则执行特殊分裂操作
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 对于链表节点，维持顺序并重新分配到新桶
else { // preserve order
Node<K,V> loHead = null, loTail = null; // 低位链表头尾指针
Node<K,V> hiHead = null, hiTail = null; // 高位链表头尾指针
Node<K,V> next;
do {
next = e.next;
// 根据hash值确定节点应分配到新表的哪个部分
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 将处理好的链表分别放入新表对应位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead; // 高位链表应放置在原索引加上旧容量的位置
}
}
}
}
}
return newTab; // 返回扩容后的新哈希表
}
ConcurrentHashMap
触发扩容的检查
在addCount方法中，有一个环节用于检查是否需要扩容：
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
if (check <= 1) {
// 省略其他逻辑...
}
else if (as = counterCells != null ||
!U.compareAndSwapLong(this, BASECOUNT, v = baseCount, s = v + x)) {
// 省略其他逻辑...
}
// 检查是否需要扩容
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
while ((tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY &&
(sc = sizeCtl) >= 0) {
if (sc < n << RESIZE_STAMP_SHIFT) {
if ((sc >>> RESIZE_STAMP_SHIFT) != resizeStamp(n) || sc == resizeStamp(n) + 1 ||
sc == resizeStamp(n) + MAX_RESIZERS || transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, null);
}
// 其他情况省略...
}
}
}
/**
* 负责在扩容时将原哈希表中的节点重新分配到新的、更大的哈希表中。
* 实现并发安全的节点迁移，以支持HashMap在使用过程中的动态扩容。
*
* @param tab 当前正在使用的哈希表数组
* @param nextTab 新的、扩容后的哈希表数组
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length; // 获取当前哈希表的长度
int stride; // 每个线程处理的步长，用于并发转移
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // 如果计算出的步长太小，则设置最小步长
// 初始化新哈希表，如果尚未初始化
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; // 标记是否所有桶都至少被尝试过一次转移
// 主循环，负责桶的遍历和转移
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))) {
bound = nextBound;
i = nextIndex - 1;
advance = false; // 更新转移范围并准备处理下一个桶
}
}
// 检查是否结束循环
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) { // 如果完成阶段，提交新表并更新控制状态
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 准备进入完成阶段，减少sizeCtl并重置i
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; // 已经被其他线程转移
else { // 正常桶的转移处理
synchronized (f) { // 锁住桶头节点，防止并发修改
if (tabAt(tab, i) == f) { // 确保桶未被其他线程改变
Node<K,V> ln, hn; // 用于存储低位和高位链表
if (fh >= 0) { // 处理链表桶
// 初始化runBit为当前桶头节点的哈希值与原哈希表长度-1的按位与结果
int runBit = fh & n;
// 初始化lastRun为当前桶的第一个节点，即f自身
Node<K,V> lastRun = f;
// 遍历当前桶中的链表
for (Node<K,V> p = f.next; p != null; p = p.next) {
// 计算当前节点p的哈希值与原哈希表长度-1的按位与结果
int b = p.hash & n;
// 检查当前节点的runBit是否与之前的不同
if (b != runBit) {
// 如果不同，说明遇到了需要划分到不同桶的节点
// 更新runBit为当前节点的b值，并记录下这个作为新runBit的第一个节点lastRun
runBit = b;
lastRun = p;
}
}
// 根据最后的runBit决定高低位链表的分配
// 如果runBit为0，说明从f到lastRun这一段应该分配到新表的低位桶（索引不变）
if (runBit == 0) {
ln = lastRun; // ln链表指向lastRun，包含从f到lastRun的节点
hn = null; // hn链表为空，因为所有处理的节点都属于低位
}
// 否则，runBit不为0，这一段应该分配到新表的高位桶（索引加上原表长度）
else {
hn = lastRun; // hn链表指向lastRun，包含从f到lastRun的节点
ln = null; // ln链表为空，因为所有处理的节点都属于高位
}
// 遍历当前桶中的链表，根据节点的hash值分配到ln（低位链表）或hn（高位链表）
for (Node<K,V> p = f; p != null; p = p.next) {
int ph = p.hash;
K pk = p.key;
V pv = p.val;
Node<K,V> newNode = new Node<>(ph, pk, pv, null);
if ((ph & n) == 0) {
if (ln == null)
ln = newNode;
else
ln.next = newNode;
} else {
if (hn == null)
hn = newNode;
else
hn.next = newNode;
}
}
// 将拆分后的链表放入新哈希表的对应位置
setTabAt(nextTab, i, ln); // 低位链表放回原索引
setTabAt(nextTab, i + n, hn); // 高位链表放在新索引
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;
// 遍历树节点，根据hash值分配到lo（低位树）或hi（高位树）
for (Node<K,V> e = t.first; e != null; e = e.next) {
TreeNode<K,V> p = new TreeNode<>(e.hash, e.key, e.val, null, null);
if ((p.hash & n) == 0) {
if (loTail == null)
lo = p;
else
loTail.next = p;
loTail = p;
lc++;
} else {
if (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; // 标记可以处理下一个桶
}
}
} // synchronized 结束
} // if (fh >= 0) 或 (f instanceof TreeBin) 结束
} // else (桶非空且未转移) 结束
} // 主循环结束
} // transfer 方法结束
transfer方法是Java ConcurrentHashMap类中的核心方法之一，其主要职责是在哈希表扩容时，将原哈希表中的所有节点（包括链表节点和树节点）高效且安全地迁移到一个新的、容量更大的哈希表中。以下是该方法的关键点总结：
1）并发转移: 利用多线程并发执行，每个处理器负责哈希表的一部分桶进行迁移，提高了扩容效率，同时确保操作的线程安全性。
2）步长计算: 动态计算每个线程的处理步长（stride），平衡并发度与竞争，特别是在CPU核心数较多时，合理分配每个线程的工作量。
3）新表初始化: 在第一次调用时，会创建一个两倍于原表大小的新哈希表，并处理可能的OutOfMemoryError异常。
4）桶的遍历与转移:
- 使用transferIndex和bound来控制遍历范围，逐步推进，确保所有桶都被处理。
- 对于空桶，直接设置转发节点。
- 对于已标记为“MOVED”的桶，跳过处理（已被其他线程处理）。
- 对于链表桶，根据节点的哈希值将其分割为两个链表，分别放置在新表的原索引和原索引+n的位置。
- 对于树形桶（当链表长度超过阈值时转换而成），同样进行拆分处理，可能重新调整为链表或新的树形结构。
5）控制转移流程:
- 使用finishing标志来确保所有桶至少被检查过一次，之后进入最终的整理阶段，提交新表并更新控制状态。
- 通过CAS操作保证操作的原子性和一致性，减少线程间的直接竞争。
6）桶内同步: 在处理非空桶时，通过同步块锁定桶头节点，确保同一时间只有一个线程能操作该桶，保证了在并发环境下的数据一致性。
7）树形节点的处理: 特别处理了树形桶的拆分，将树拆分为两个部分，可能重新转换为链表或新的树结构，确保数据结构的优化。
总之，transfer方法通过精细的并发控制和数据结构操作，实现了高效且线程安全的哈希表扩容过程，是ConcurrentHashMap高并发性能的关键实现之一。
三、putIfAbsent方法computeIfAbsent方法区别
场景代码
public static void main(String[] args) {
test(new HashMap<>());
test(new ConcurrentHashMap<>());
}
private static void test(Map<String, String> map) {
log.info("class : {}", map.getClass().getName());
try {
log.info("putIfAbsent test1 null value : {}", map.putIfAbsent("test1", null));
} catch (Exception ex) {
ex.printStackTrace();
}
log.info("test containsKey test1 after putIfAbsent : {}", map.containsKey("test1"));
log.info("computeIfAbsent test2 null value : {}", map.computeIfAbsent("test2", k -> "20"));
log.info("test containsKey test2 after computeIfAbsent : {}", map.containsKey("test2"));
log.info("putIfAbsent test3 non-null value : {}", map.putIfAbsent("test3", "test3"));
log.info("computeIfAbsent test4 non-null value : {}", map.computeIfAbsent("test4", k -> "test4"));
log.info("putIfAbsent test4 expensive value : {}", map.putIfAbsent("test4", getValue()));
log.info("computeIfAbsent test4 expensive value : {}", map.computeIfAbsent("test4", k -> getValue()));
}
private static String getValue() {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
return UUID.randomUUID().toString();
}
传入HashMap结果：
传入ConcurrentHashMap结果：
结论：
前提：HashMap只可以有一个K=null，V随意；ConcurrentHashMap的K-V 都!=null
putIfAbsent：当K-V不存在，将待插入的K-V插入，返回null；当K-V存在，返回当前K-V的值，有函数也不更新；computeIfAbsent：当K-V不存在，将对应K的计算结果插入（但是当V=null，则不插入K-null）；当K-V存在，返回原映射中的值；
看完笔者这篇文章余兴不足，还可以看看别人的
HashMap和ConcurrentHashMap的区别，详解HashMap和ConcurrentHashMap数据结构
标签：Node,ConcurrentHashMap,Java,HashMap,tab,链表,哈希,null,节点 From： https://blog.csdn.net/kdzandlbj/article/details/139963483