2024年面试官：ConcurrentHashMap 是如何保证线程安全的(1)，2024年最新费时6个月成功入职阿里

//查看是否在扩容，先不看，扩容再介绍

else if ((fh = f.hash) == MOVED)

//帮助扩容

tab = helpTransfer(tab, f);

else {

V oldVal = null;

//对Node对象进行加锁

synchronized (f) {

//二次确认此Node对象还是原来的那一个

if (tabAt(tab, i) == f) {

if (fh >= 0) {

binCount = 1;

//无限循环，直到完成put

for (Node<K,V> e = f;; ++binCount) {

K ek;

//和HashMap一样，先比较hash，再比较equals

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) {

//和链表头Node节点不冲突，就将其初始化为新Node作为上一个Node节点的next

//形成链表结构

pred.next = new Node<K,V>(hash, key,

value, null);

break;

}

}

}

…

}

值得关注的是tabAt(tab, i)方法，其使用Unsafe类volatile的操作volatile式地查看值，保证每次获取到的值都是最新的：

static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {

return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);

}

虽然上面的table变量加了volatile，但也只能保证其引用的可见性，并不能确保其数组中的对象是否是最新的，所以需要Unsafe类volatile式地拿到最新的Node。

总结

由于其减小了锁的粒度，若Hash完美不冲突的情况下，可同时支持n个线程同时put操作，n为Node数组大小，在默认大小16下，可以支持最大同时16个线程无竞争同时操作且线程安全。当hash冲突严重时，Node链表越来越长，将导致严重的锁竞争，此时会进行扩容，将Node进行再散列，下面会介绍扩容的线程安全性。总结一下用到的并发技巧：

• 减小锁粒度：将Node链表的头节点作为锁，若在默认大小16情况下，将有16把锁，大大减小了锁竞争（上下文切换），就像开头所说，将串行的部分最大化缩小，在理想情况下线程的put操作都为并行操作。同时直接锁住头节点，保证了线程安全
• Unsafe的getObjectVolatile方法：此方法确保获取到的值为最新。

5、扩容操作的线程安全

---

在扩容时，ConcurrentHashMap支持多线程并发扩容，在扩容过程中同时支持get查数据，若有线程put数据，还会帮助一起扩容，这种无阻塞算法，将并行最大化的设计，堪称一绝。

先来看看扩容代码实现：

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {

int n = tab.length, stride;

//根据机器CPU核心数来计算，一条线程负责Node数组中多长的迁移量

if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)

//本线程分到的迁移量

//假设为16（默认也为16）

stride = MIN_TRANSFER_STRIDE; // subdivide range

//nextTab若为空代表线程是第一个进行迁移的

//初始化迁移后的新Node数组

if (nextTab == null) {            // initiating

try {

@SuppressWarnings(“unchecked”)

//这里n为旧数组长度，左移一位相当于乘以2

//例如原数组长度16，新数组长度则为32

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变量为新数组

nextTable = nextTab;

//假设为16

transferIndex = n;

}

//假设为32

int nextn = nextTab.length;

//标示Node对象，此对象的hash变量为-1

//在get或者put时若遇到此Node，则可以知道当前Node正在迁移

//传入nextTab对象

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;

//i为当前正在处理的Node数组下标，每次处理一个Node节点就会自减1

if (–i >= bound || finishing)

advance = false;

//假设nextIndex=16

else if ((nextIndex = transferIndex) <= 0) {

i = -1;

advance = false;

}

//由以上假设，nextBound就为0

//且将nextIndex设置为0

else if (U.compareAndSwapInt

(this, TRANSFERINDEX, nextIndex,

nextBound = (nextIndex > stride ?

nextIndex - stride : 0))) {

//bound=0

bound = nextBound;

//i=16-1=15

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;

}

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

}

}

//此时i=15，取出Node数组下标为15的那个Node，若为空则不需要迁移

//直接设置占位标示，代表此Node已处理完成

else if ((f = tabAt(tab, i)) == null)

advance = casTabAt(tab, i, null, fwd);

//检测此Node的hash是否为MOVED，MOVED是一个常量-1，也就是上面说的占位Node的hash

//如果是占位Node，证明此节点已经处理过了，跳过i=15的处理，继续循环

else if ((fh = f.hash) == MOVED)

advance = true; // already processed

else {

//锁住这个Node

synchronized (f) {

//确认Node是原先的Node

if (tabAt(tab, i) == f) {

//ln为lowNode，低位Node，hn为highNode，高位Node

//这两个概念下面以图来说明

Node<K,V> ln, hn;

if (fh >= 0) {

//此时fh与原来Node数组长度进行与运算

//如果高X位为0，此时runBit=0

//如果高X位为1，此时runBit=1

int runBit = fh & n;

Node<K,V> lastRun = f;

for (Node<K,V> p = f.next; p != null; p = p.next) {

//这里的Node，都是同一Node链表中的Node对象

int b = p.hash & n;

if (b != runBit) {

runBit = b;

lastRun = p;

}

}

//正如上面所说，runBit=0，表示此Node为低位Node

if (runBit == 0) {

ln = lastRun;

hn = null;

}

else {

//Node为高位Node

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;

//若hash和n与运算为0，证明为低位Node，原理同上

if ((ph & n) == 0)

ln = new Node<K,V>(ph, pk, pv, ln);

//这里将高位Node与地位Node都各自组成了两个链表

else

hn = new Node<K,V>(ph, pk, pv, hn);

}

//将低位Node设置到新Node数组中，下标为原来的位置

setTabAt(nextTab, i, ln);

//将高位Node设置到新Node数组中，下标为原来的位置加上原Node数组长度

setTabAt(nextTab, i + n, hn);

//将此Node设置为占位Node，代表处理完成

setTabAt(tab, i, fwd);

//继续循环

advance = true;

}

…

}

}

}

}

}

这里说一下迁移时为什么要分一个ln（低位Node）、hn（高位Node），首先说一个现象：

我们知道，在put值的时候，首先会计算hash值，再散列到指定的Node数组下标中：

//根据key的hashCode再散列

int hash = spread(key.hashCode());

//使用(n - 1) & hash 运算，定位Node数组中下标值

(f = tabAt(tab, i = (n - 1) & hash);

其中n为Node数组长度，这里假设为16。

假设有一个key进来，它的散列之后的hash=9，那么它的下标值是多少呢？

• （16 - 1）和 9 进行与运算 -> 0000 1111 和 0000 1001 结果还是 0000 1001 = 9

假设Node数组需要扩容，我们知道，扩容是将数组长度增加两倍，也就是32，那么下标值会是多少呢？

• （32 - 1）和 9 进行与运算 -> 0001 1111 和 0000 1001 结果还是9

此时，我们把散列之后的hash换成20，那么会有怎样的变化呢？

• （16 - 1）和 20 进行与运算 -> 0000 1111 和 0001 0100 结果是 0000 0100 = 4
• （32 - 1）和 20 进行与运算 -> 0001 1111 和 0001 0100 结果是 0001 0100 = 20

此时细心的读者应该可以发现，如果hash在高X位为1，（X为数组长度的二进制-1的最高位），则扩容时是需要变换在Node数组中的索引值的，不然就hash不到，丢失数据，所以这里在迁移的时候将高X位为1的Node分类为hn，将高X位为0的Node分类为ln。

回到代码中：

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);

}

这个操作将高低位组成了两条链表结构，由下图所示：

然后将其CAS操作放入新的Node数组中：

setTabAt(nextTab, i, ln);

setTabAt(nextTab, i + n, hn);

其中，低位链表放入原下标处，而高位链表则需要加上原Node数组长度，其中为什么不多赘述，上面已经举例说明了，这样就可以保证高位Node在迁移到新Node数组中依然可以使用hash算法散列到对应下标的数组中去了。

最后将原Node数组中对应下标Node对象设置为fwd标记Node，表示该节点迁移完成，到这里，一个节点的迁移就完成了，将进行下一个节点的迁移，也就是i-1=14下标的Node节点。

扩容时的get操作：

假设Node下标为16的Node节点正在迁移，突然有一个线程进来调用get方法，正好key又散列到下标为16的节点，此时怎么办？

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;

}

//假如Node节点的hash值小于0

//则有可能是fwd节点

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;

}

重点看有注释的那两行，在get操作的源码中，会判断Node中的hash是否小于0，是否还记得我们的占位Node，其hash为MOVED，为常量值-1，所以此时判断线程正在迁移，委托给fwd占位Node去查找值：

//内部类 ForwardingNode中

Node<K,V> find(int h, Object k) {

// loop to avoid arbitrarily deep recursion on forwarding nodes

// 这里的查找，是去新Node数组中查找的

// 下面的查找过程与HashMap查找无异，不多赘述

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;

}

else

return e.find(h, k);

}

if ((e = e.next) == null)

return null;

}

}

}

到这里应该可以恍然大悟了，之所以占位Node需要保存新Node数组的引用也是因为这个，它可以支持在迁移的过程中照样不阻塞地查找值，可谓是精妙绝伦的设计。

多线程协助扩容

在put操作时，假设正在迁移，正好有一个线程进来，想要put值到迁移的Node上，怎么办？

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;                   // no lock when adding to empty bin

}

//若此时发现了占位Node，证明此时HashMap正在迁移

else if ((fh = f.hash) == MOVED)

//进行协助迁移

tab = helpTransfer(tab, f);

…

}

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;

//sizeCtl加一，标示多一个线程进来协助扩容

if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {

//扩容

transfer(tab, nextTab);

break;

}

}

return nextTab;

}

return table;

}

此方法涉及大量复杂的位运算，这里不多赘述，只是简单的说几句，此时sizeCtl变量用来标示HashMap正在扩容，当其准备扩容时，会将sizeCtl设置为一个负数，（例如数组长度为16时）其二进制表示为：

1000 0000 0001 1011 0000 0000 0000 0010

无符号位为1，表示负数。其中高16位代表数组长度的一个位算法标示（有点像epoch的作用，表示当前迁移朝代为数组长度X），低16位表示有几个线程正在做迁移，刚开始为2，接下来自增1，线程迁移完会进行减1操作，也就是如果低十六位为2，代表有一个线程正在迁移，如果为3，代表2个线程正在迁移以此类推…

只要数组长度足够长，就可以同时容纳足够多的线程来一起扩容，最大化并行任务，提高性能。

在什么情况下会进行扩容操作？

• 在put值时，发现Node为占位Node（fwd）时，会协助扩容。
• 在新增节点后，检测到链表长度大于8时。

final V putVal(K key, V value, boolean onlyIfAbsent) {

…

if (binCount != 0) {

//TREEIFY_THRESHOLD=8，当链表长度大于8时

if (binCount >= TREEIFY_THRESHOLD)

//调用treeifyBin方法

treeifyBin(tab, i);

if (oldVal != null)

return oldVal;

break;

}

…

}

treeifyBin方法会将链表转换为红黑树，增加查找效率，但在这之前，会检查数组长度，若小于64，则会优先做扩容操作：

private final void treeifyBin(Node<K,V>[] tab, int index) {

Node<K,V> b; int n, sc;

if (tab != null) {

//MIN_TREEIFY_CAPACITY=64

//若数组长度小于64，则先扩容

if ((n = tab.length) < MIN_TREEIFY_CAPACITY)

//扩容

tryPresize(n << 1);

else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {

synchronized (b) {

//…转换为红黑树的操作

}

}

}

}

在每次新增节点之后，都会调用addCount方法，检测Node数组大小是否达到阈值：

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数网络安全工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上网络安全知识点！真正的体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

Node<K,V>[] tab, int index) {

Node<K,V> b; int n, sc;

if (tab != null) {

//MIN_TREEIFY_CAPACITY=64

//若数组长度小于64，则先扩容

if ((n = tab.length) < MIN_TREEIFY_CAPACITY)

//扩容

tryPresize(n << 1);

else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {

synchronized (b) {

//…转换为红黑树的操作

}

}

}

}

在每次新增节点之后，都会调用addCount方法，检测Node数组大小是否达到阈值：

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数网络安全工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

[外链图片转存中…(img-xa6NtJ5e-1715803077661)]

[外链图片转存中…(img-66TbCeCm-1715803077662)]

[外链图片转存中…(img-705fy3ca-1715803077662)]

[外链图片转存中…(img-o9Sj8Svh-1715803077662)]

[外链图片转存中…(img-fwdsvcLh-1715803077662)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上网络安全知识点！真正的体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！