jdk8 ConcurrentHashMap源码与bug分析
欢迎转载，转载请注明网址:https://blog.csdn.net/qq_41910280
简介
分析了ConcurrentHashMap源码中的put、初始化、扩容等过程。重要的就是理解如何降低锁粒度提升并发度，以及如何多线程协同扩容。
版本说明
2022-01-14 init
2022-10-19 新增前言 HashMap的并发问题描述
文章目录
前言
HashMap有哪些并发问题?
1.新增或者删除
涉及链表或者树的操作, 具体包括:
链表: 当线程一在A节点后面添加B节点, 线程二删除A节点就导致B节点被一起删除
树: 旋转的时候进行操作会产生覆盖
2.扩容
扩容的时候新增可能新增到旧的table
1. put()操作
put很简单 和HashMap也差不多，主要多了synchronized头节点的步骤，另外key和value都不允许null
后面类似单线程操作红黑树等基操我就不细说了，不懂的先补数据结构和算法
扩容的具体过程看后面
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
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)
// 1.table为null 初始化
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 2.映射的table节点为null 直接新增
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)
// 3.正在扩容 本线程也一起去并发扩容
tab = helpTransfer(tab, f);
else {
// 4.在链表或红黑树上添加节点(红黑树添加节点时, 如果table[].length<64则扩容)
V oldVal = null;
// 以前是分段锁 现在只锁头结点 进一步降低所粒度
// 以前是Segment继承ReentrantLock 现在使用synchronized因为synchronized性能更高 也便于jvm优化(ps 如果用不到Lock的高级功能都建议使用synchronized)
synchronized (f) {
if (tabAt(tab, i) == f) {// 预防多个线程同时新增一个bucket的头节点或者头节点刚被移除
// 头节点hash>=0为链表 走链表新增
// 因为红黑树的头节点的hash固定为TREEBIN(-2) 而链表节点hash通过spread()计算都>0(&HASH_BITS)
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;
}
}
}
// 节点总数+1 (尝试cas新增baseCount,如果失败就根据线程随机到一个CounterCell去新增, 为了降低并发竞争)
addCount(1L, binCount);
return null;
}
2. 初始化表格initTable()
需要先理解一个变量sizeCtl 和一个函数resizeStamp()
/**
* 在初始化完成之前,没有指定初始大小默认是0,>0是表的初始大小
* 扩容时,(最高的一位一定是1, 因此<0)
* 高16位是扩容标识(计算见resizeStamp())
* 低16位如果是1表示在初始化 N表示有N-1个线程在扩容,
* 其他情况下是扩容阈值
*/
private transient volatile int sizeCtl;
resizeStamp()是用来生成扩容标识
/**
* 第一个线程扩容时会执行这行代码 U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)
* 1 << (RESIZE_STAMP_BITS - 1) 将rs第16位设置为1, (rs << RESIZE_STAMP_SHIFT) + 2 后sizeCtl一定是负数 (高16位是rs,低16位是2,代表有1个线程参与扩容)
* 本函数计算的结果rs作为高16位的唯一扩容标记(因为n是2的倍数所以每次扩容之后 Integer.numberOfLeadingZeros(n) 都会变化)
*/
static final int resizeStamp(int n) {
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
有了这些基础之后再来看初始化
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)// 其他线程在初始化
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
// 初始化
try {
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);// 阈值0.75*n
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
3. 并发扩容helpTransfer和transfer
需要先看初始化中sizeCtl和resizeStamp部分
扩容可以理解为消费者模式, 表的每一个bucket都是一个需要处理的任务或者产品, 因此可以多个线程并发协同去处理
transferIndex 正是用来在多个线程中分配任务的控制变量
/**
* 指向下一个需要转移的bucket
*/
private transient volatile int transferIndex;
helpTransfer(当前线程join扩容大军)
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// instanceof ForwardingNode表示表正在扩容(当前bucket被其他线程)
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) {// 小于0说明还在扩容
// 扩容标志发生了变化(扩容结束) || 扩容即将结束 || 达到最大并发扩容线程数量 || 没有需要分配的任务
// sc == rs + 1 || sc == rs + MAX_RESIZERS有bug, 在jdk17这个方法内的rs变量赋值语句为
// int rs = resizeStamp(n) << RESIZE_STAMP_SHIFT;
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// 扩容线程数量增加1
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
具体去扩容的方法函数transfer
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// stride是用来分配任务的范围, 即一次分配多少任务
// stride 在单核下直接等于 n，多核模式下为 (n>>>3)/NCPU，最小值是 16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
if (nextTab == null) { // initiating
// 如果nextTab为null 则初始化新表
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;// 倒序获取bucket(可能为了避免处理溢出)
}
int nextn = nextTab.length;
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;// 是否继续获取下一个bucket
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)// --i >= bound 获得的任务还没处理完 配合for循环继续处理(每完成一个bucket还是会设置advance为true), 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))) {
// 获得nextIndex-1到nextBound的任务
// i是上界 bound是下界
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {// i < 0表示任务已经被分配完了
int sc;
if (finishing) {
// 更新table
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);// 更新阈值+扩容标识
return;
}
// 第一个扩容的线程会设置 sizeCtl = (rs << RESIZE_STAMP_SHIFT) + 2
// 因此最后一个完成扩容的线程 (sc - 2) == resizeStamp(n)
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)
// 在空bucket放置fwd标识再扩容 预防其他线程put到旧表
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
// 已经处理了 直接去下一个bucket
advance = true; // already processed
else {
// 开始处理这个bucket
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
// 处理链表
// 将链表节点为低位链表ln和高位链表hn, 后续ln设置在原位置i的位置,hn设置在i+n的位置, 无需重新散列
// 原理是 散列时&(n-1)与&(2n-1)区别只在于hash在2n-1比n-1高的那一位是0或是1
int runBit = fh & n;// 为0是低位 不为0是高位
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);
// 标记为fwd
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);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
参考文献
1.https://www.sohu.com/a/320372210_120176035
2.jdk源码
3.本活动与苹果公司无关[滑稽]
本人邮箱：zhouyouchn@126.com zhoooooouyou@gmail.com
zhouyou@whut.edu.cn 欢迎交流，共同进步。
欢迎转载，转载请注明本网址。
2739
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
