JDK 8 ConcurrentHashMap 源码详解（详细注释版）
1. 类定义和基本属性
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
// 序列化版本号，用于序列化时版本控制
private static final long serialVersionUID = 7249069246763182397L;
/**
* CPU核心数，用于确定并发级别和扩容时的线程数量
* 这个值决定了在扩容时最多可以有多少个线程同时参与扩容操作
*/
private static final int NCPU = Runtime.getRuntime().availableProcessors();
/**
* 数组最大容量，减去8是为了避免内存溢出
* 在某些JVM实现中，数组的最大长度是Integer.MAX_VALUE - 2或更小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 默认初始容量，必须是2的幂次方
* 选择16是因为这是一个经验性的平衡点，既不会太小导致频繁扩容，也不会太大浪费内存
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* 最大容量，必须是2的幂次方
* 这个限制是为了确保哈希算法的正确性和性能
*/
private static final int MAX_CAPACITY = 1 << 30;
/**
* 默认并发级别（已废弃，仅为兼容性保留）
* 在JDK 1.7及以前版本中，这个参数用于控制分段锁的数量
* 在JDK 1.8中，这个概念已经被废弃，但为了向后兼容仍然保留
*/
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 默认负载因子，与HashMap相同
* 负载因子决定了何时进行扩容，0.75是一个时间和空间复杂度的平衡点
* 当元素数量超过容量*负载因子时，会触发扩容操作
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 树化阈值：链表转红黑树的阈值
* 当链表长度达到8时，如果数组长度也达到一定要求，就会转换为红黑树
* 这个阈值是通过泊松分布计算得出的经验值，可以平衡查找效率
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 反树化阈值：红黑树转链表的阈值
* 当红黑树节点数量减少到6时，会转换回链表
* 设置为6而不是8是为了避免频繁的树化和反树化操作
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 最小树化容量：只有数组长度达到这个值才会进行树化
* 这是为了避免在小数组中进行不必要的树化操作
* 当数组长度小于64时，即使链表长度达到8，也只会进行扩容而不是树化
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 扩容时每个线程最少处理的桶数量
* 这个值是为了确保每个参与扩容的线程都能获得足够的工作量
* 避免线程过多导致的资源浪费
*/
private static final int MIN_TRANSFER_STRIDE = 16;
/**
* 生成sizeCtl字段的标记位数
* 用于在扩容过程中标识不同的状态和线程数
* 16位用于标识扩容批次，剩余位用于记录参与扩容的线程数
*/
private static final int RESIZE_STAMP_BITS = 16;
/**
* 最大并发扩容线程数
* 通过位运算计算得出：(1 << (32 - RESIZE_STAMP_BITS)) - 1
* 这个限制是为了避免过多的线程同时参与扩容导致性能下降
*/
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
/**
* 移位量，用于记录扩容进度
* 在sizeCtl字段中，高位存储扩容标记，低位存储线程计数
* 通过这个移位量可以将两个信息分开存储
*/
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
/**
* 转发节点的哈希值标记
* 当节点的哈希值为-1时，表示这是一个转发节点
* 转发节点用于在扩容过程中标识已经处理过的桶
*/
static final int MOVED = -1; // hash for forwarding nodes
/**
* 红黑树根节点的哈希值标记
* 当节点的哈希值为-2时，表示这是一个红黑树容器节点
* 这种节点包含了整个红黑树的根节点信息
*/
static final int TREEBIN = -2; // hash for roots of trees
/**
* 保留节点的哈希值标记
* 当节点的哈希值为-3时，表示这是一个保留节点
* 主要用于临时占位，在某些特殊操作中使用
*/
static final int RESERVED = -3; // hash for transient reservations
/**
* 哈希掩码，用于清除最高位符号位
* 通过与这个掩码进行按位与操作，可以确保哈希值为正数
* 这样可以避免负数哈希值带来的特殊处理
*/
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
/**
* 存储节点的数组，这是ConcurrentHashMap的核心数据结构
* 采用volatile修饰确保多线程环境下的内存可见性
* 当数组需要扩容时，会创建新的数组并逐步迁移数据
*/
transient volatile Node<K,V>[] table;
/**
* 扩容时使用的新数组
* 在扩容过程中，数据会从table数组逐步迁移到nextTable数组
* 扩容完成后，nextTable会成为新的table
*/
private transient volatile Node<K,V>[] nextTable;
/**
* 控制标识符，这是一个非常重要的字段，用于控制ConcurrentHashMap的各种状态：
* -1：表示正在初始化table数组
* -N：表示正在扩容，其中N表示参与扩容的线程数加1
* 0：默认值，表示需要初始化table数组
* >0：当table为null时，表示初始化时的容量；当table不为null时，表示下一次扩容的阈值
*/
private transient volatile int sizeCtl;
/**
* 扩容时下一个要处理的索引
* 在多线程扩容时，每个线程都会从transferIndex获取一段连续的桶进行处理
* 这个字段确保了不同线程处理不同的数据段，避免重复工作
*/
private transient volatile int transferIndex;
/**
* CAS自旋锁，用于减少扩容时的竞争
* 当多个线程尝试更新计数器或参与扩容时，会使用这个锁来保证原子性
* 采用CAS操作实现，避免了传统锁的开销
*/
private transient volatile int cellsBusy;
/**
* 计数器数组，用于高并发下的size计算
* 在高并发环境下，如果只有一个基础计数器，会导致严重的竞争
* 通过将计数器分散到多个Cell中，可以显著减少竞争，提高性能
*/
private transient volatile CounterCell[] counterCells;
/**
* 基础计数器，在没有竞争时使用
* 当只有一个线程进行计数操作时，直接使用这个字段，避免了数组访问的开销
* 当检测到竞争时，会切换到counterCells数组进行分散计数
*/
private transient volatile long baseCount;
2. 节点内部类（详细注释）
/**
* 基本的哈希表节点，这是ConcurrentHashMap中最基本的数据结构
* 每个节点包含键、值、哈希值和指向下一个节点的引用
* 所有节点都继承自这个类，包括链表节点和红黑树节点
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; // 哈希值，用于快速定位桶位置
final K key; // 键，使用final修饰确保不可变性
volatile V val; // 值，使用volatile修饰确保内存可见性
volatile Node<K,V> next; // 下一个节点，使用volatile修饰确保内存可见性
/**
* 构造方法，创建一个新的节点
* @param hash 节点的哈希值
* @param key 节点的键
* @param val 节点的值
* @param next 指向下一个节点的引用
*/
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
/**
* 获取节点的键
* @return 节点的键
*/
public final K getKey() { return key; }
/**
* 获取节点的值
* @return 节点的值
*/
public final V getValue() { return val; }
/**
* 计算节点的哈希码
* 通过键和值的哈希码进行异或运算，确保哈希分布均匀
* @return 节点的哈希码
*/
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
/**
* 返回节点的字符串表示
* 格式为"key=value"，便于调试和日志输出
* @return 节点的字符串表示
*/
public final String toString(){ return key + "=" + val; }
/**
* 设置节点的值（不支持）
* 由于ConcurrentHashMap的节点值不应该被直接修改，
* 所以这个方法会抛出UnsupportedOperationException异常
* @param value 新的值
* @return 旧的值
* @throws UnsupportedOperationException 不支持的操作异常
*/
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
/**
* 比较两个节点是否相等
* 两个节点相等当且仅当它们的键和值都相等
* @param o 要比较的对象
* @return 如果相等返回true，否则返回false
*/
public final boolean equals(Object o) {
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (key.equals(e.getKey()) && val.equals(e.getValue()))
return true;
}
return false;
}
}
/**
* 转发节点，用于扩容时标识已经处理过的桶
* 当一个桶的数据被迁移到新数组后，原桶位置会放置一个转发节点
* 转发节点指向新数组，这样其他线程访问时可以知道数据已经迁移
*/
static final class ForwardingNode<K,V> extends Node<K,V> {
// 指向新数组的引用，用于数据迁移完成后的访问
final Node<K,V>[] nextTable;
/**
* 构造方法，创建一个转发节点
* @param tab 指向新数组的引用
*/
ForwardingNode(Node<K,V>[] tab) {
// 调用父类构造方法，哈希值设为MOVED(-1)，键值都为null
super(MOVED, null, null, null);
this.nextTable = tab;
}
/**
* 在转发节点中查找指定键的节点
* 由于数据已经迁移到新数组，所以需要在新数组中查找
* @param h 键的哈希值
* @param k 要查找的键
* @return 找到的节点，如果没找到返回null
*/
Node<K,V> find(int h, Object k) {
// 外层循环：处理嵌套的转发节点情况
outer: for (Node<K,V>[] tab = nextTable;;) {
Node<K,V> e; int n;
// 检查参数有效性并获取桶位置的头节点
if (k == null || tab == null || (n = tab.length) == 0 ||
(e = tabAt(tab, (n - 1) & h)) == null)
return null;
// 内层循环：在链表或树中查找
for (;;) {
int eh; K ek;
// 如果找到匹配的节点，直接返回
if ((eh = e.hash) == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
// 如果遇到负哈希值（特殊节点）
if (eh < 0) {
// 如果是转发节点，继续外层循环处理嵌套情况
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
continue outer;
}
// 如果是其他特殊节点，调用其find方法
else
return e.find(h, k);
}
// 移动到下一个节点
if ((e = e.next) == null)
return null;
}
}
}
}
/**
* 红黑树节点，用于实现红黑树数据结构
* 当链表长度超过阈值时，会转换为红黑树以提高查找效率
* 红黑树节点继承自普通节点，增加了树结构相关的指针
*/
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent; // 父节点指针，用于树的遍历和操作
TreeNode<K,V> left; // 左子节点指针，维护二叉搜索树性质
TreeNode<K,V> right; // 右子节点指针，维护二叉搜索树性质
TreeNode<K,V> prev; // 删除时需要的前驱节点，用于链表操作
boolean red; // 颜色标志，true表示红色，false表示黑色
/**
* 构造方法，创建一个红黑树节点
* @param hash 节点的哈希值
* @param key 节点的键
* @param val 节点的值
* @param next 指向下一个节点的引用（链表结构）
*/
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* 返回树的根节点
* 通过不断向上查找父节点，直到找到没有父节点的节点
* @return 红黑树的根节点
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
/**
* 在红黑树中查找指定哈希值和键的节点
* 利用红黑树的有序性质进行二分查找，时间复杂度为O(log n)
* @param h 要查找的哈希值
* @param k 要查找的键
* @param kc 键的类，用于类型比较
* @return 找到的节点，如果没找到返回null
*/
final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
// 从当前节点开始查找
TreeNode<K,V> p = this;
do {
int ph, dir; K pk; TreeNode<K,V> q;
TreeNode<K,V> pl = p.left, pr = p.right;
// 如果当前节点哈希值大于目标哈希值，在左子树中查找
if ((ph = p.hash) > h)
p = pl;
// 如果当前节点哈希值小于目标哈希值，在右子树中查找
else if (ph < h)
p = pr;
// 如果哈希值相等且键相等，找到目标节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 如果左右子树都为空，说明没找到
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
// 如果需要进行详细比较
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
// 在右子树中查找
else if ((q = pr.findTreeNode(h, k, kc)) != null)
return q;
// 在左子树中查找
else
p = pl;
} while (p != null);
return null;
}
}
/**
* 红黑树容器节点，用于包装整个红黑树结构
* 当桶中的链表转换为红黑树时，桶头节点会变成TreeBin节点
* TreeBin节点包含了红黑树的根节点和其他管理信息
*/
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root; // 红黑树的根节点
volatile TreeNode<K,V> first; // 链表形式的头节点，用于快速遍历
volatile Thread waiter; // 最近的一个设置WAITER状态的线程，用于线程调度
volatile int lockState; // 锁状态，用于控制并发访问
// 锁状态常量定义
static final int WRITER = 1; // 设置写锁状态，表示有写操作正在进行
static final int WAITER = 2; // 等待写锁状态，表示有线程在等待写锁
static final int READER = 4; // 增加读锁状态，表示有读操作正在进行
/**
* 构造方法，创建一个TreeBin节点
* @param b 红黑树的第一个节点
*/
TreeBin(TreeNode<K,V> b) {
// 调用父类构造方法，哈希值设为TREEBIN(-2)，键值都为null
super(TREEBIN, null, null, null);
this.first = b;
// 构建红黑树结构
TreeNode<K,V> r = null;
for (TreeNode<K,V> x = b, next; x != null; x = 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) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
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);
}
/**
* 在红黑树中查找节点
* 这个方法处理了并发访问的情况，确保线程安全
* @param h 键的哈希值
* @param k 要查找的键
* @return 找到的节点，如果没找到返回null
*/
final Node<K,V> find(int h, Object k) {
if (k != null) {
// 遍历链表形式的节点
for (Node<K,V> e = first; e != null; ) {
int s; K ek;
// 如果当前有写操作或等待写操作，直接在线性链表中查找
if (((s = lockState) & (WAITER|WRITER)) != 0) {
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
e = e.next;
}
// 尝试获取读锁
else if (U.compareAndSwapInt(this, LOCKSTATE, s,
s + READER)) {
TreeNode<K,V> r, p;
try {
// 在红黑树中查找
p = ((r = root) == null ? null :
r.findTreeNode(h, k, null));
} finally {
// 释放读锁，如果需要唤醒等待的写线程则唤醒
Thread w;
if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
(READER|WAITER) && (w = waiter) != null)
LockSupport.unpark(w);
}
return p;
}
}
}
return null;
}
/**
* 在红黑树中插入节点
* 这个方法处理了并发访问的情况，确保线程安全
* @param h 键的哈希值
* @param k 要插入的键
* @param v 要插入的值
* @return 如果是更新操作返回旧节点，如果是插入操作返回null
*/
final TreeNode<K,V> putTreeVal(int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
// 获取红黑树的根节点
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
// 如果树为空，直接插入根节点
if (p == null) {
first = root = new TreeNode<K,V>(h, k, v, null);
break;
}
// 确定插入方向
else if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.findTreeNode(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.findTreeNode(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
// 找到插入位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
TreeNode<K,V> x, f = first;
first = x = new TreeNode<K,V>(h, k, v, f);
if (f != null)
f.prev = x;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
if (!xp.red)
x.red = true;
else {
lockRoot();
try {
root = balanceInsertion(root, x);
} finally {
unlockRoot();
}
}
break;
}
}
assert checkInvariants(root);
return null;
}
/**
* 从红黑树中删除节点
* 这个方法处理了并发访问的情况，确保线程安全
* @param p 要删除的节点
* @return 如果删除成功返回true，否则返回false
*/
final boolean removeTreeNode(TreeNode<K,V> p) {
TreeNode<K,V> next = (TreeNode<K,V>)p.next;
TreeNode<K,V> pred = p.prev;
TreeNode<K,V> r, rl;
// 更新链表连接
if (pred == null)
first = next;
else
pred.next = next;
if (next != null)
next.prev = pred;
if (first == null) {
root = null;
return true;
}
// 如果树结构简单，不需要复杂的删除操作
if ((r = root) == null || r.right == null ||
(rl = r.left) == null || rl.left == null)
return true;
// 获取写锁并执行删除操作
lockRoot();
try {
TreeNode<K,V> replacement;
TreeNode<K,V> pl = p.left;
TreeNode<K,V> pr = p.right;
if (pl != null && pr != null) {
TreeNode<K,V> s = pr, sl;
while ((sl = s.left) != null)
s = sl;
boolean c = s.red; s.red = p.red; p.red = c;
TreeNode<K,V> sr = s.right;
TreeNode<K,V> pp = p.parent;
if (s == pr) {
p.parent = s;
s.right = p;
}
else {
TreeNode<K,V> sp = s.parent;
if ((p.parent = sp) != null) {
if (s == sp.left)
sp.left = p;
else
sp.right = p;
}
if ((s.right = pr) != null)
pr.parent = s;
}
p.left = null;
if ((p.right = sr) != null)
sr.parent = p;
if ((s.left = pl) != null)
pl.parent = s;
if ((s.parent = pp) == null)
r = s;
else if (p == pp.left)
pp.left = s;
else
pp.right = s;
if (sr != null)
replacement = sr;
else
replacement = p;
}
else if (pl != null)
replacement = pl;
else if (pr != null)
replacement = pr;
else
replacement = p;
if (replacement != p) {
TreeNode<K,V> pp = replacement.parent = p.parent;
if (pp == null)
r = replacement;
else if (p == pp.left)
pp.left = replacement;
else
pp.right = replacement;
p.left = p.right = p.parent = null;
}
root = (p.red) ? r : balanceDeletion(r, replacement);
if (p == replacement) {
TreeNode<K,V> pp;
if ((pp = p.parent) != null) {
if (p == pp.left)
pp.left = null;
else if (p == pp.right)
pp.right = null;
p.parent = null;
}
}
} finally {
unlockRoot();
}
assert checkInvariants(root);
return false;
}
/**
* 获取写锁
* 这个方法使用自旋和等待机制来获取写锁
*/
private final void lockRoot() {
if (!U.compareAndSwapInt(this, LOCKSTATE, 0, WRITER))
contendedLock(); // offload to separate method
}
/**
* 释放写锁
* 这个方法简单地将锁状态重置为0
*/
private final void unlockRoot() {
lockState = 0;
}
/**
* 有竞争时的加锁方法
* 当多个线程竞争写锁时，使用这个方法来处理
*/
private final void contendedLock() {
boolean waiting = false;
for (int s;;) {
if (((s = lockState) & ~WAITER) == 0) {
if (U.compareAndSwapInt(this, LOCKSTATE, s, WRITER)) {
if (waiting)
waiter = null;
return;
}
}
else if ((s & WAITER) == 0) {
if (U.compareAndSwapInt(this, LOCKSTATE, s, s | WAITER)) {
waiting = true;
waiter = Thread.currentThread();
}
}
else if (waiting)
LockSupport.park(this);
}
}
}
/**
* 计数器单元，用于高并发环境下的计数操作
* 通过将计数器分散到多个Cell中，可以减少竞争，提高性能
*/
@sun.misc.Contended static final class CounterCell {
volatile long value; // 计数器的值
/**
* 构造方法，创建一个计数器单元
* @param x 初始值
*/
CounterCell(long x) { value = x; }
}
3. 构造方法（详细注释）
/**
* 默认构造方法，创建一个空的ConcurrentHashMap
* 不会立即初始化table数组，而是在第一次插入数据时进行初始化
* 这种延迟初始化的策略可以节省内存，避免创建不必要的空数组
*/
public ConcurrentHashMap() {
// sizeCtl保持默认值0，表示需要初始化
}
/**
* 指定初始容量的构造方法
* @param initialCapacity 初始容量，必须是非负数
* @throws IllegalArgumentException 如果初始容量为负数
*/
public ConcurrentHashMap(int initialCapacity) {
// 参数有效性检查
if (initialCapacity < 0)
throw new IllegalArgumentException();
// 计算实际的容量，考虑到负载因子的影响
int cap = ((initialCapacity >= (MAX_CAPACITY >>> 1)) ?
MAX_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
// 设置sizeCtl为计算出的容量，用于初始化时的容量设置
this.sizeCtl = cap;
}
/**
* 指定初始容量和负载因子的构造方法
* @param initialCapacity 初始容量
* @param loadFactor 负载因子
* @throws IllegalArgumentException 如果参数不合法
*/
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
// 调用三参数构造方法，concurrencyLevel设为1
this(initialCapacity, loadFactor, 1);
}
/**
* 指定初始容量、负载因子和并发级别的构造方法
* @param initialCapacity 初始容量
* @param loadFactor 负载因子
* @param concurrencyLevel 并发级别（已废弃，仅用于兼容性）
* @throws IllegalArgumentException 如果参数不合法
*/
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
// 参数有效性检查
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// 确保初始容量至少等于并发级别
if (initialCapacity < concurrencyLevel)
initialCapacity = concurrencyLevel;
// 计算所需的容量大小
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
// 确定最终的容量
int cap = (size >= (long)MAX_CAPACITY) ?
MAX_CAPACITY : tableSizeFor((int)size);
// 设置sizeCtl为计算出的容量
this.sizeCtl = cap;
}
/**
* 从Map构造ConcurrentHashMap
* @param m 包含初始数据的Map
* @throws NullPointerException 如果m为null
*/
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
// 设置默认初始容量
this.sizeCtl = DEFAULT_CAPACITY;
// 将传入Map中的所有数据添加到当前Map中
putAll(m);
}
/**
* 计算大于等于给定值的最小2的幂次
* 这个方法确保容量始终是2的幂次方，便于哈希计算和扩容操作
* @param c 给定的值
* @return 大于等于c的最小2的幂次
*/
private static final int tableSizeFor(int c) {
// 减1是为了处理c本身已经是2的幂次的情况
int n = c - 1;
// 通过位运算快速计算下一个2的幂次
n |= n >>> 1; // 将最高位的1向右扩散1位
n |= n >>> 2; // 将最高位的1向右扩散2位
n |= n >>> 4; // 将最高位的1向右扩散4位
n |= n >>> 8; // 将最高位的1向右扩散8位
n |= n >>> 16; // 将最高位的1向右扩散16位
// 处理边界情况并返回结果
return (n < 0) ? 1 : (n >= MAX_CAPACITY) ? MAX_CAPACITY : n + 1;
}
4. 核心添加方法（详细注释）
/**
* 添加键值对到ConcurrentHashMap中
* 如果键已经存在，则更新其值；如果键不存在，则添加新的键值对
* @param key 键，不能为null
* @param value 值，不能为null
* @return 如果是更新操作返回旧值，如果是插入操作返回null
* @throws NullPointerException 如果key或value为null
*/
public V put(K key, V value) {
// 调用核心添加方法，onlyIfAbsent参数设为false表示允许更新
return putVal(key, value, false);
}
/**
* 如果指定的键不存在，则添加键值对
* 这是一个原子操作，适用于需要避免覆盖现有值的场景
* @param key 键，不能为null
* @param value 值，不能为null
* @return 如果添加成功返回null，如果键已存在返回旧值
* @throws NullPointerException 如果key或value为null
*/
public V putIfAbsent(K key, V value) {
// 调用核心添加方法，onlyIfAbsent参数设为true表示不允许更新
return putVal(key, value, true);
}
/**
* ConcurrentHashMap的核心添加方法
* 这个方法实现了线程安全的添加操作，是整个类的核心
* @param key 键，不能为null
* @param value 值，不能为null
* @param onlyIfAbsent 是否只在键不存在时添加
* @return 如果是更新操作返回旧值，如果是插入操作返回null
* @throws NullPointerException 如果key或value为null
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 参数有效性检查，ConcurrentHashMap不允许null键和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;
// 如果table数组为空或长度为0，需要初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable(); // 初始化表
// 如果目标桶为空，尝试直接CAS插入
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; // no lock when adding to empty bin
}
// 如果遇到转发节点，说明正在扩容，需要帮助扩容
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;
// 根据onlyIfAbsent参数决定是否更新
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;
// 根据onlyIfAbsent参数决定是否更新
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;
}
/**
* 哈希值扰动函数，用于改善哈希分布
* 通过将哈希值的高位和低位进行异或运算，可以减少哈希冲突
* @param h 原始哈希值
* @return 扰动后的哈希值
*/
static final int spread(int h) {
// 将哈希值与其右移16位的结果进行异或，然后与HASH_BITS掩码进行按位与
// HASH_BITS掩码确保结果为正数，避免负数哈希值带来的特殊处理
return (h ^ (h >>> 16)) & HASH_BITS;
}
/**
* 初始化表数组
* 这个方法使用CAS操作确保只有一个线程能够初始化数组
* 其他线程会等待初始化完成
* @return 初始化完成的表数组
*/
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 循环直到初始化完成
while ((tab = table) == null || tab.length == 0) {
// 如果sizeCtl小于0，说明有其他线程正在初始化，当前线程让出CPU时间片
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// 尝试通过CAS操作将sizeCtl设为-1，表示当前线程正在初始化
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 再次检查table是否已经被初始化
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;
// 计算下次扩容的阈值：n - (n >>> 2) = n * 0.75
sc = n - (n >>> 2);
}
} finally {
// 初始化完成后，将sizeCtl设为扩容阈值
sizeCtl = sc;
}
break;
}
}
return tab;
}
/**
* 将链表转换为红黑树
* 当链表长度达到阈值且数组长度足够大时，会调用此方法进行转换
* @param tab 当前的表数组
* @param index 要转换的桶的索引
*/
private final void treeifyBin(Node<K,V>[] tab, int index) {
int n, sc;
// 检查参数有效性
if (tab != null) {
// 如果数组长度小于最小树化容量，优先考虑扩容而不是树化
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1); // 扩容
// 如果数组长度足够大，进行树化操作
else if (n >= MIN_TREEIFY_CAPACITY) {
// 获取指定索引位置的头节点
Node<K,V> b; int c;
if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 对头节点加锁
synchronized (b) {
// 再次检查节点是否发生变化
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null;
// 将链表中的所有节点转换为红黑树节点
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);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
// 用TreeBin节点替换原来的头节点
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
}
/**
* 尝试预扩容
* 在树化之前，如果数组长度不够，会先进行扩容
* @param size 预扩容的目标大小
*/
private final void tryPresize(int size) {
// 计算扩容后的容量
int c = (size >= (MAX_CAPACITY >>> 1)) ? MAX_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
// 循环直到扩容完成或确定不需要扩容
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
// 如果table为空或容量不足，需要扩容
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
// 尝试初始化或扩容
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
// 如果当前容量已经足够或达到最大容量，不需要扩容
else if (c <= sc || n >= MAX_CAPACITY)
break;
// 如果table没有发生变化，开始扩容
else if (tab == table) {
int rs = resizeStamp(n);
// 如果sizeCtl小于0，说明正在扩容
if (sc < 0) {
Node<K,V>[] nt;
// 检查扩容状态是否正常
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 增加参与扩容的线程数
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 开始新的扩容操作
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
5. 核心获取方法（详细注释）
/**
* 获取指定键对应的值
* 这是一个高效的读操作，不需要加锁
* @param key 要查找的键
* @return 键对应的值，如果键不存在返回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());
// 检查table是否有效且不为空
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)
// 调用特殊节点的find方法
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;
}
/**
* 判断ConcurrentHashMap是否包含指定的键
* 通过调用get方法实现，如果get返回非null值则说明包含该键
* @param key 要检查的键
* @return 如果包含该键返回true，否则返回false
*/
public boolean containsKey(Object key) {
return get(key) != null;
}
/**
* 判断ConcurrentHashMap是否包含指定的值
* 需要遍历整个Map来查找，性能相对较低
* @param value 要检查的值
* @return 如果包含该值返回true，否则返回false
* @throws NullPointerException 如果value为null
*/
public boolean containsValue(Object value) {
// 参数有效性检查
if (value == null)
throw new NullPointerException();
Node<K,V>[] t;
// 如果table不为空，进行遍历查找
if ((t = table) != null) {
// 创建遍历器
Traverser<K,V> it = new Traverser<K,V>(t, t.length, 0, t.length);
// 逐个检查节点的值
for (Node<K,V> p; (p = it.advance()) != null; ) {
V v;
// 如果找到匹配的值，返回true
if ((v = p.val) == value || (v != null && value.equals(v)))
return true;
}
}
return false;
}
/**
* 获取ConcurrentHashMap中的键集合
* 返回的集合是动态的，会反映Map的当前状态
* @return 键集合
*/
public Set<K> keySet() {
Set<K> ks;
// 使用延迟初始化模式
return (ks = keySet) != null ? ks : (keySet = new KeySetView<K,V>(this, null));
}
/**
* 获取ConcurrentHashMap中的值集合
* 返回的集合是动态的，会反映Map的当前状态
* @return 值集合
*/
public Collection<V> values() {
ValuesView<K,V> vs;
// 使用延迟初始化模式
return (vs = values) != null ? vs : (values = new ValuesView<K,V>(this));
}
/**
* 获取ConcurrentHashMap中的键值对集合
* 返回的集合是动态的，会反映Map的当前状态
* @return 键值对集合
*/
public Set<Map.Entry<K,V>> entrySet() {
EntrySetView<K,V> es;
// 使用延迟初始化模式
return (es = entrySet) != null ? es : (entrySet = new EntrySetView<K,V>(this));
}
6. 删除方法（详细注释）
/**
* 删除指定键的映射关系
* @param key 要删除的键
* @return 被删除的值，如果键不存在返回null
*/
public V remove(Object key) {
// 调用替换节点方法，将值设为null表示删除
return replaceNode(key, null, null);
}
/**
* 只有当当前值等于指定值时才删除
* 这是一个原子操作，适用于需要条件删除的场景
* @param key 要删除的键
* @param value 期望的当前值
* @return 如果删除成功返回true，否则返回false
* @throws NullPointerException 如果key或value为null
*/
public boolean remove(Object key, Object value) {
// 参数有效性检查
if (key == null)
throw new NullPointerException();
// 调用替换节点方法进行条件删除
return value != null && replaceNode(key, null, value) != null;
}
/**
* 替换节点的核心方法
* 这个方法实现了删除和条件替换操作
* @param key 要操作的键
* @param value 新值，如果为null表示删除
* @param cv 期望的当前值，用于条件操作
* @return 旧值，如果操作失败返回null
*/
final V replaceNode(Object key, V value, Object cv) {
// 计算键的哈希值
int hash = spread(key.hashCode());
// 无限循环，直到操作完成
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 如果table为空或目标桶为空，说明键不存在
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null)
break;
// 如果遇到转发节点，说明正在扩容，需要帮助扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 如果桶中有数据，需要进行同步操作
else {
V oldVal = null;
boolean validated = false;
// 对桶头节点加锁
synchronized (f) {
// 再次检查桶头节点是否发生变化
if (tabAt(tab, i) == f) {
// 如果是普通链表节点
if (fh >= 0) {
validated = true;
// 遍历链表查找和操作
for (Node<K,V> e = f, pred = null;;) {
K ek;
// 如果找到匹配的节点
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
V ev = e.val;
// 如果是条件操作，检查值是否匹配
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) {
oldVal = ev;
// 如果不是删除操作，更新值
if (value != null)
e.val = value;
// 如果是删除操作，从链表中移除节点
else if (pred != null)
pred.next = e.next;
else
setTabAt(tab, i, e.next);
}
break;
}
pred = e;
// 如果到达链表末尾，说明没找到
if ((e = e.next) == null)
break;
}
}
// 如果是红黑树节点
else if (f instanceof TreeBin) {
validated = true;
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> r, p;
// 在红黑树中查找节点
if ((r = t.root) != null &&
(p = r.findTreeNode(hash, key, null)) != null) {
V pv = p.val;
// 如果是条件操作，检查值是否匹配
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) {
oldVal = pv;
// 如果不是删除操作，更新值
if (value != null)
p.val = value;
// 如果是删除操作，从红黑树中移除节点
else if (t.removeTreeNode(p))
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
// 如果操作成功，更新计数器
if (validated) {
if (oldVal != null) {
// 如果是删除操作，减少计数器
if (value == null)
addCount(-1L, -1);
return oldVal;
}
break;
}
}
}
return null;
}
7. 替换方法（详细注释）
/**
* 替换指定键的值
* @param key 要替换的键
* @param value 新值
* @return 旧值，如果键不存在返回null
*/
public V replace(K key, V value) {
// 参数有效性检查
if (key == null || value == null)
throw new NullPointerException();
// 调用替换节点方法进行替换
return replaceNode(key, value, null);
}
/**
* 只有当当前值等于指定值时才替换
* 这是一个原子操作，适用于需要条件替换的场景
* @param key 要替换的键
* @param oldValue 期望的当前值
* @param newValue 新值
* @return 如果替换成功返回true，否则返回false
*/
public boolean replace(K key, V oldValue, V newValue) {
// 参数有效性检查
if (key == null || oldValue == null || newValue == null)
throw new NullPointerException();
// 调用替换节点方法进行条件替换
return replaceNode(key, newValue, oldValue) != null;
}
8. 扩容机制（详细注释）
/**
* 帮助扩容
* 当一个线程发现其他线程正在进行扩容时，会调用此方法参与扩容
* 这样可以充分利用多核CPU的并行处理能力
* @param tab 当前的表数组
* @param f 转发节点
* @return 新的表数组
*/
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 检查参数有效性
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 计算扩容标记
int rs = resizeStamp(tab.length);
// 循环直到扩容完成或确定不需要帮助
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
// 检查扩容状态是否正常
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// 增加参与扩容的线程数
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 调用transfer方法参与扩容
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
/**
* 扩容的核心方法
* 这个方法实现了数据从旧数组到新数组的迁移
* 支持多线程并行扩容，提高扩容效率
* @param tab 旧的表数组
* @param 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
// 如果nextTab为null，说明是第一次调用transfer，需要初始化
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设为最大值，避免继续扩容
sizeCtl = Integer.MAX_VALUE;
return;
}
// 设置nextTable字段
nextTable = nextTab;
// 设置transferIndex为原数组长度
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
// 无限循环，处理所有需要迁移的桶
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，将nextTab设为table
nextTable = null;
table = nextTab;
// 计算新的sizeCtl值
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);
// 在原数组对应位置放置转发节点
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 (TreeNode<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);
// 在原数组对应位置放置转发节点
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
/**
* 计算扩容标记
* 这个标记用于在sizeCtl字段中标识扩容状态
* @param n 原数组长度
* @return 扩容标记
*/
static final int resizeStamp(int n) {
// 通过位运算计算扩容标记
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
9. 计数器机制（详细注释）
/**
* 更新计数器
* 这个方法用于更新ConcurrentHashMap中元素的数量
* 支持高并发环境下的计数操作
* @param x 要增加的数量（可以为负数表示减少）
* @param check 是否需要检查扩容
*/
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// 尝试直接更新baseCount
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
// 如果counterCells数组为空或CAS失败，需要使用CounterCell
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
// 调用fullAddCount方法处理竞争
fullAddCount(x, uncontended);
return;
}
// 如果不需要检查扩容，直接返回
if (check <= 1)
return;
// 计算当前元素总数
s = sumCount();
}
// 检查是否需要扩容
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// 循环检查是否需要扩容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAX_CAPACITY) {
// 计算扩容标记
int rs = resizeStamp(n);
// 如果正在扩容
if (sc < 0) {
// 检查扩容状态是否正常
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 增加参与扩容的线程数
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 开始新的扩容操作
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
// 重新计算元素总数
s = sumCount();
}
}
}
/**
* 在高竞争情况下的计数方法
* 当多个线程同时更新计数器时，会调用此方法处理竞争
* @param x 要增加的数量
* @param wasUncontended 是否之前没有竞争
*/
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
// 获取当前线程的probe值
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
// 如果counterCells数组已经初始化
if ((as = counterCells) != null && (n = as.length) > 0) {
// 如果对应位置的CounterCell为空
if ((a = as[(n - 1) & h]) == null) {
// 如果cellsBusy锁未被占用
if (cellsBusy == 0) { // Try to attach new Cell
CounterCell r = new CounterCell(x); // Optimistic create
// 尝试获取cellsBusy锁
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
// 再次检查并创建新的CounterCell
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;
}
} finally {
cellsBusy = 0;
}
if (created)
break;
continue; // Slot is now non-empty
}
}
collide = false;
}
// 如果之前有竞争，重新计算probe值
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
// 尝试更新CounterCell的值
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
// 如果数组长度达到最大值或有其他线程在初始化
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
// 如果没有冲突，设置冲突标志
else if (!collide)
collide = true;
// 如果需要扩容且cellsBusy锁未被占用
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
// 再次检查并扩容
if (counterCells == as) {// Expand table unless stale
CounterCell[] rs = new CounterCell[n << 1];
for (int i = 0; i < n; ++i)
rs[i] = as[i];
counterCells = rs;
}
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
// 重新计算probe值
h = ThreadLocalRandom.advanceProbe(h);
}
// 如果counterCells数组未初始化且cellsBusy锁未被占用
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
// 再次检查并初始化counterCells数组
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2];
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
// 直接更新baseCount
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
/**
* 计算元素总数
* 通过累加baseCount和所有CounterCell的值来获得准确的总数
* @return 元素总数
*/
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
// 获取baseCount的值
long sum = baseCount;
// 如果counterCells数组不为空，累加所有CounterCell的值
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
/**
* 获取ConcurrentHashMap中元素的数量
* 这是一个估算值，在并发环境下可能不准确
* @return 元素数量
*/
public int size() {
long n = sumCount();
// 确保返回值在合理范围内
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
/**
* 判断ConcurrentHashMap是否为空
* @return 如果为空返回true，否则返回false
*/
public boolean isEmpty() {
return sumCount() <= 0L; // ignore transient negative values
}
10. CAS操作和工具方法（详细注释）
/**
* 获取指定位置的节点
* 使用volatile语义确保内存可见性
* @param tab 节点数组
* @param i 索引位置
* @return 指定位置的节点
*/
@SuppressWarnings("unchecked")
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
// 使用Unsafe的getObjectVolatile方法获取volatile对象
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
/**
* CAS设置指定位置的节点
* 这是一个原子操作，确保线程安全
* @param tab 节点数组
* @param i 索引位置
* @param c 预期的当前值
* @param v 新值
* @return 如果设置成功返回true，否则返回false
*/
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
// 使用Unsafe的compareAndSwapObject方法进行CAS操作
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
/**
* 设置指定位置的节点
* 使用volatile语义确保内存可见性
* @param tab 节点数组
* @param i 索引位置
* @param v 新值
*/
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
// 使用Unsafe的putObjectVolatile方法设置volatile对象
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
/**
* 将链表节点转换为普通节点
* 当红黑树节点数量减少到阈值以下时，会调用此方法转换为链表
* @param b 红黑树的第一个节点
* @return 转换后的链表头节点
*/
static <K,V> Node<K,V> untreeify(Node<K,V> b) {
Node<K,V> hd = null, tl = null;
// 遍历红黑树节点，创建对应的普通节点
for (Node<K,V> q = b; q != null; q = q.next) {
Node<K,V> p = new Node<K,V>(q.hash, q.key, q.val, null);
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
/**
* Unsafe操作工具类，提供底层的原子操作
* 这些操作直接使用CPU的原子指令，性能非常高
*/
private static final sun.misc.Unsafe U;
// 各个字段在对象中的偏移量，用于Unsafe操作
private static final long SIZECTL;
private static final long TRANSFERINDEX;
private static final long BASECOUNT;
private static final long CELLSBUSY;
private static final long CELLVALUE;
private static final long ABASE;
private static final int ASHIFT;
// 静态初始化块，初始化Unsafe和各个字段的偏移量
static {
try {
U = sun.misc.Unsafe.getUnsafe();
Class<?> k = ConcurrentHashMap.class;
// 获取各个字段的偏移量
SIZECTL = U.objectFieldOffset
(k.getDeclaredField("sizeCtl"));
TRANSFERINDEX = U.objectFieldOffset
(k.getDeclaredField("transferIndex"));
BASECOUNT = U.objectFieldOffset
(k.getDeclaredField("baseCount"));
CELLSBUSY = U.objectFieldOffset
(k.getDeclaredField("cellsBusy"));
Class<?> ck = CounterCell.class;
CELLVALUE = U.objectFieldOffset
(ck.getDeclaredField("value"));
Class<?> tk = Node[].class;
// 获取数组的基地址和元素大小
ABASE = U.arrayBaseOffset(tk);
int scale = U.arrayIndexScale(tk);
// 确保数组元素大小是2的幂次
if ((scale & (scale - 1)) != 0)
throw new Error("data type scale not a power of two");
// 计算数组索引的移位量
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
} catch (Exception e) {
throw new Error(e);
}
}
11. ConcurrentHashMap 的特点分析
核心设计思想：
/**
* ConcurrentHashMap的核心设计：
*
* 1. 分段锁机制（JDK 1.7）-> CAS + synchronized（JDK 1.8）
* - JDK 1.7：将整个数组分成多个段，每段独立加锁
* - JDK 1.8：取消分段，直接对桶头节点加锁，配合CAS操作
*
* 2. 数组 + 链表 + 红黑树的混合数据结构
* - 默认使用链表存储冲突的元素
* - 当链表长度超过阈值时转换为红黑树
* - 红黑树提供O(log n)的查找性能
*
* 3. 无锁化设计，减少线程阻塞
* - 读操作不需要加锁，利用volatile保证内存可见性
* - 写操作使用CAS和细粒度锁，减少锁竞争
*
* 4. 扩容时的多线程协助机制
* - 当一个线程发现正在扩容时，会主动参与扩容
* - 多个线程可以并行处理不同的数据段
*
* 5. 高并发下的计数器分离
* - 使用baseCount和CounterCell数组分散计数
* - 避免单一计数器的竞争
*
* 主要改进（JDK 1.7 -> JDK 1.8）：
* - 取消分段锁，改用CAS + synchronized，减少内存开销
* - 引入红黑树优化链表过长问题，提高查找性能
* - 扩容时多线程协助，提高扩容效率
* - 计数器分离优化，提高计数性能
* - 删除节点时的优化，减少不必要的操作
*/
并发安全机制详解：
-
CAS操作：
- 用于无锁化插入和状态更新
- 直接使用CPU的原子指令，性能极高
- 避免了传统锁的开销和阻塞
-
synchronized：
- 对桶头节点加锁，粒度更细
- 减少了锁的竞争范围
- JDK 1.6后的synchronized性能已经大大优化
-
volatile：
- 保证内存可见性
- 确保多线程环境下数据的一致性
- 避免了不必要的同步开销
-
Unsafe：
- 提供底层原子操作
- 实现高效的CAS和内存访问
- 是整个并发机制的基础
性能特征分析：
/**
* ConcurrentHashMap的性能特征：
*
* 时间复杂度分析：
* - get操作：O(1) 平均情况，利用哈希直接定位
* - put/remove操作：O(1) 平均情况，最坏O(log n)（红黑树）
* - 扩容操作：O(n) 但支持多线程并行，实际影响较小
* - size操作：O(1) 到 O(n)，取决于计数器的状态
*
* 空间复杂度：O(n)
* - 存储n个键值对
* - 扩容时需要额外的O(n)空间
* - 计数器数组O(log n)空间
*
* 并发特性：
* - 高并发读写性能，读操作完全无锁
* - 无死锁风险，使用CAS和细粒度锁
* - 弱一致性：迭代器不保证实时一致性
* - 内存一致性：通过volatile和synchronized保证
*
* 扩容机制：
* - 渐进式扩容，避免一次性大量内存分配
* - 多线程协助扩容，提高效率
* - 转发节点机制，确保数据一致性
*/
12. 使用示例和最佳实践
/**
* 使用示例：
*
* // 基本使用
* ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
*
* // 基本操作
* map.put("key1", 1);
* Integer value = map.get("key1");
* System.out.println("Value: " + value);
*
* // 原子操作
* map.putIfAbsent("key2", 2); // 只在键不存在时添加
* map.replace("key1", 1, 10); // 条件替换
*
* // 计算操作
* map.computeIfAbsent("key3", k -> 3); // 计算并添加
* map.compute("key1", (k, v) -> v == null ? 1 : v + 1); // 计算并更新
*
* // 批量操作
* map.forEach((k, v) -> System.out.println(k + "=" + v));
*
* // 并发安全的迭代
* for (Map.Entry<String, Integer> entry : map.entrySet()) {
* System.out.println(entry.getKey() + "=" + entry.getValue());
* }
*
* 最佳实践：
*
* 1. 合理设置初始容量：
* ConcurrentHashMap<String, Integer> map =
* new ConcurrentHashMap<>(1000); // 预估容量，避免频繁扩容
*
* 2. 避免在映射操作中进行耗时计算：
* // 不好的做法
* map.computeIfAbsent("key", k -> expensiveCalculation(k));
*
* // 好的做法
* if (!map.containsKey("key")) {
* ValueType value = expensiveCalculation("key");
* map.putIfAbsent("key", value);
* }
*
* 3. 注意弱一致性的迭代器：
* // 迭代过程中其他线程的修改可能看不到
* Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
* while (it.hasNext()) {
* Map.Entry<String, Integer> entry = it.next();
* // 处理entry
* }
*
* 4. 合理使用原子操作方法：
* // 使用原子操作避免竞态条件
* map.merge("counter", 1, Integer::sum);
* map.compute("key", (k, v) -> v == null ? 1 : v + 1);
*
* 5. 监控扩容和树化的影响：
* // 在高并发写入场景下，注意扩容对性能的影响
* // 可以通过JVM参数调整相关阈值
*
* 6. 避免存储null值：
* // ConcurrentHashMap不允许null键和null值
* // map.put("key", null); // 会抛出NullPointerException
*
* 7. 合理使用size()方法：
* // size()方法返回的是估算值，在高并发下可能不准确
* // 如果需要精确计数，应该自己维护计数器
*
* 8. 注意内存使用：
* // ConcurrentHashMap的内存开销比HashMap大
* // 在内存敏感的应用中需要权衡
*/
13. 与其他并发集合的比较
/**
* ConcurrentHashMap vs HashMap vs Hashtable vs Collections.synchronizedMap:
*
* ConcurrentHashMap:
* - 线程安全，高性能
* - 读操作无锁，写操作细粒度锁
* - 弱一致性迭代器
* - 不允许null键和null值
* - 支持原子操作和批量操作
*
* HashMap:
* - 非线程安全
* - 性能最好
* - 强一致性迭代器
* - 允许null键和null值
* - 需要外部同步才能线程安全
*
* Hashtable:
* - 线程安全，但性能较差
* - 所有操作都加锁
* - 强一致性迭代器
* - 不允许null键和null值
* - 已被废弃，不推荐使用
*
* Collections.synchronizedMap:
* - 通过包装器实现线程安全
* - 所有操作都加锁
* - 强一致性迭代器（需要手动同步）
* - 允许null键和null值
* - 性能不如ConcurrentHashMap
*
* 选择建议：
* - 高并发读写：ConcurrentHashMap
* - 单线程使用：HashMap
* - 简单同步需求：Collections.synchronizedMap
* - 已有遗留代码：Hashtable（但建议迁移到ConcurrentHashMap）
*/
14. 总结
ConcurrentHashMap 的核心特性：
-
线程安全：
- 通过CAS和synchronized保证并发安全
- 读操作无锁，写操作细粒度锁
- 无死锁风险
-
高性能：
- 读操作完全无锁
- 写操作使用CAS和细粒度锁
- 多线程协助扩容
-
可扩展性：
- 支持动态扩容
- 多线程并行扩容
- 渐进式数据迁移
-
数据结构：
- 数组+链表+红黑树的混合结构
- 链表长度超过阈值时自动转换为红黑树
- 红黑树节点数量减少时自动转换为链表
-
弱一致性：
- 迭代器不保证实时一致性
- 适用于大多数并发场景
适用场景：
- 高并发读写场景
- 缓存实现
- 多线程数据共享
- 需要线程安全的Map操作
- 分布式系统中的本地缓存
注意事项：
- 迭代器是弱一致性的
- 不支持null键和null值
- 扩容时性能会有短暂下降
- 内存开销比HashMap大
- size()方法返回的是估算值
性能优化建议：
- 合理设置初始容量，避免频繁扩容
- 避免在映射操作中进行耗时计算
- 合理使用原子操作方法
- 监控扩容和树化的影响
- 在内存敏感的应用中权衡使用
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
