1.基础介绍
在日常开发中使用的 HashMap 是线程不安全的，而线程安全类 HashTable 只是简单的在方法上加锁实现了线程安全，效率低下，所以在线程安全的环境下我们通常会使用 ConcurrentHashMap
package java.util.concurrent;
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {}
2.主要属性
// 散列表最大容量
private static final int MAXIMUM_CAPACITY = 1 << 30;
// 散列表默认容量
private static final int DEFAULT_CAPACITY = 16;
// 最大数组长度
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 默认并发级别 jdk1.7 之前遗留的 1.8只用于初始化
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 负载因子
private static final float LOAD_FACTOR = 0.75f;
// 链表树化条件
static final int TREEIFY_THRESHOLD = 8;
// 取消树化条件
static final int UNTREEIFY_THRESHOLD = 6;
// 结点树化条件
static final int MIN_TREEIFY_CAPACITY = 64;
// 线程迁移数据最小步长 控制线程迁移任务最小区间的一个值
private static final int MIN_TRANSFER_STRIDE = 16;
// 扩容用 计算扩容生成一个标识戳
private static final int RESIZE_STAMP_BITS = 16;
// 65535 标识并发扩容最大线程数量
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 扩容相关
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// node 结点的hash 是-1 表示 当前结点是forwardingNode结点
static final int MOVED = -1; // hash for forwarding nodes
// 红黑树的代理结点
static final int TREEBIN = -2; // hash for roots of trees
// 临时保留的散列表
static final int RESERVED = -3; // hash for transient reservations
// 0x7fffffff = 31个1 用于将一个负数变成一个正数 但是不是取绝对值
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
3.重要概念
table
所有数据都存在table中，table的容量会根据实际情况进行扩容，table[i]存放的数据类型有以下3种：
- TreeBin 红黑树节点
- Node 普通节点类型
- ForwardingNode 扩容时存放的节点类型，并发扩容的实现关键之一
sizeCtl
以volatile修饰的sizeCtl用于数组初始化与扩容控制，它有以下几个值：
private transient volatile int sizeCtl;
当前未初始化:
= 0 // 未指定初始容量,int默认就是0
> 0 // 创建的时候,构造方法中赋值容量,默认16
初始化中：
= -1 // table正在初始化,这个时候代表一个标识,其它线程看到是-1,就会Thread.yield()让出CPU,让初始化尽快完成
= -N // N是int类型，分为两部分，高15位是指定容量标识，低16位表示
// 并行扩容线程数+1，具体在resizeStamp函数介绍。
初始化完成：
table.length * 0.75 // 扩容阈值调为table容量大小的0.75倍
4.构造方法
看过HashMap的，看这个就很简单了
public ConcurrentHashMap() {
}
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
5.内部类
ForwardingNode
static final class ForwardingNode<K,V> extends Node<K,V> {
// 如果在存取的时候,获取到的节点类型是ForwardingNode,此时put()操作会协助扩容,get()操作调用find()方法继续查找
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
// 1.首先获取新位置的头节点是否为我们要找的
// 2.判断是调用链表的find()还是红黑树的find()方法遍历查找
Node<K,V> find(int h, Object k) {
// loop to avoid arbitrarily deep recursion on forwarding nodes
outer: for (Node<K,V>[] tab = nextTable;;) {
Node<K,V> e; int n;
// 基础判断
// 这里会 e 赋值为新链表中该hash对应的头节点
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;
//eh<0
//hash值为负值表示正在扩容，这个时候查的是ForwardingNode的find方法来定位到nextTable来
//eh=-1，说明该节点是一个ForwardingNode，正在迁移，此时调用ForwardingNode的find方法去nextTable里找。
//eh=-2，说明该节点是一个TreeBin，此时调用TreeBin的find方法遍历红黑树，由于红黑树有可能正在旋转变色，所以find里会有读写锁。
if (eh < 0) {
// ForwardingNode查找节点
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K,V>)e).nextTable;
continue outer;
}
else
// 红黑树查找节点
return e.find(h, k);
}
// 走到这里,说明已经链表,因为如果是红黑树,上面已经return了
// 这里就是链表继续向下
if ((e = e.next) == null)
return null;
}
}
}
}
6.初始化时的线程安全
- 多个线程同时进入初始化方法，通过标记
sizeCtl来判断，为-1时代表有线程正在初始化，此时执行Thread.yield()让出CPU - 当
sizeCtl> 0 时，代表没有线程正在初始化，需要本线程来执行，那么通过CAS将sizeCtl设置为-1，这样其它线程进入就会按照上面第一步判断
// volatile修饰table
transient volatile Node<K,V>[] table;
// 使用了volatile关键字
// 默认值肯定为0,执行构造方法时,会给其赋值初始表大小16
// 如果为负值,代表其它线程正在初始化,此线程就重复执行了
// 初始化后，保存下一个要调整表大小的元素计数值
private transient volatile int sizeCtl;
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 每次循环都获取最新的table数组
while ((tab = table) == null || tab.length == 0) {
// sizeCtl是一个标记位，若为-1，代表有线程在进行初始化工作了
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// 将SIZECTL设置为-1,一个标记,代表本线程开始进行初始化了
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 再次检查,防止加锁期间被篡改
if ((tab = table) == null || tab.length == 0) {
// 新建table数组操作
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位，相当于乘以0.75
// 例如16经过运算为12，与乘0.75一样，只不过位运算更快
sc = n - (n >>> 2);
}
} finally {
// 将计算后的sc（12）直接赋值给sizeCtl，表示达到12长度就扩容
sizeCtl = sc;
}
break;
}
}
return tab;
}
7.get操作时的线程安全
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;
}
}
return null;
}
8.put操作时的线程安全
putVal()
- 判断table是否初始化，调用
initTable()初始化，这个方法肯定是线程安全的，上面说了 - volatile获取最新的头节点为空，直接CAS赋值返回
- 如果正在扩容，那就协助扩容
helpTransfer() - 如果没有，那就通过
synchronized锁住头节点进行put操作
public V put(K key, V value) {
return putVal(key, value, false);
}
// 参数onlyIfAbsent代表碰到相同的key,是否进行替换,默认false代表替换,也就是默认的Map不存在相同的key
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;
// 第一次存数据,需要先初始化table
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 判断头节点是否创建,tabAt()方法永远获取最新的
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 尝试使用CAS的方式创建新节点添加进去
if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))
// CAS添加成功就直接返回了
break;
}
// 前置条件 表已经创建 && 头结点不是空
// 判断头节点的hash = -1，是否为forwarding nodes,说明哈希表正在处于扩容的情况
else if ((fh = f.hash) == MOVED)
// 当前线程帮忙扩容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 锁住头节点
synchronized (f) {
// 再次查询头结点是不是等于f,防止加锁过程其它线程修改
if (tabAt(tab, i) == f) {
// 判断头节点是否为普通链表
if (fh >= 0) {
binCount = 1;
// 遍历链表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// key值相同处理
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;
// key值不重复,新节点添加到链表末尾
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;
}
}
}
}
// 默认是0, 链表遍历的时候会递增,记录链表个数
if (binCount != 0) {
// 链表长度大于8,转成红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 统计table 一共有多少数据
addCount(1L, binCount);
return null;
}
tabAt()
获取头节点永远获取最新的volatile
@SuppressWarnings("unchecked")
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
// 看到方法名中包含一个volatile,保证每次查看都是最新的
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
casTabAt()
存入头节点按照cas方式存入
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
// 存入的时候是按照CAS方式
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
synchronized存入
见上面put()，存入新节点到链表/树结构内的时候，通过synchronized锁住头节点
由于其减小了锁的粒度，若 Hash 完美不冲突的情况下，可同时支持 n 个线程同时 put 操作，n 为 Node 数组大小，在默认大小 16 下，可以支持最大同时 16 个线程无竞争同时操作且线程安全。当 Hash 冲突严重时，Node 链表越来越长，将导致严重的锁竞争，此时会进行扩容，将 Node 进行再散列
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RyqLKVdc-1652189276507)(1.png)]
9.扩容时的线程安全
在扩容时，ConcurrentHashMap 支持多线程并发扩容，在扩容过程中同时支持 get 查数据，若有线程 put 数据，还会帮助一起扩容，这种无阻塞算法，将并行最大化的设计，堪称一绝
什么时候触发扩容
- putVal()添加元素时会调用addCount()，内部检查元素个数是否达到sizeCtl
- 链表长度=8 并且数组长度 < 64，触发扩容，调用点是由
putVal()调用treeifyBin() - putAll()一次性加入大量元素，触发扩容
private final void addCount(long x, int check) {
...
//check就是结点数量，有新元素加入成功才检查是否要扩容。
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// s表示加入新元素后容量大小，计算已省略。
// 新容量大于当前扩容阈值并且小于最大扩容值才扩容，如果tab=null说明正在初始化，死循环等待初始化完成。
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n); //@1
// sc < 0 表示已经有线程在进行扩容工作
if (sc < 0) {
//条件1：检查是对容量n的扩容，保证sizeCtl与n是一块修改好的
//条件2与条件3：应该是进行sc的最小值或最大值判断。
//条件4与条件5: 确保tranfer()中的nextTable相关初始化逻辑已走完。
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)) //有新线程参与扩容则sizeCtl加1
transfer(tab, nt);
}
// 没有线程在进行扩容，将sizeCtl的值改为(rs << RESIZE_STAMP_SHIFT) + 2)
else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
transfer()
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// stride可理解成“步长”，即“数据迁移”时，每个线程要负责旧table中的多少个桶，根据几核的CPU决定“步长”
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
// 本线程分到的迁移量，假设为16（默认也为16）
stride = MIN_TRANSFER_STRIDE;
// 说明第一次扩容
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
// 创建新table数组，扩大一倍为 32,n还为16
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) {
// 将表示容量的sizeCtl 设置为最大值，然后返回
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
// 表示当前线程要进行数据迁移的桶区间
transferIndex = n;
}
int nextn = nextTab.length;
// 在get或者put时若遇到此 Node，则可以知道当前Node正在迁移
// ForwardingNode结点，当旧table的某个桶中的所有结点都迁移完后，用该结点占据这个桶
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 标识一个桶的迁移工作是否完成，advance == true 表示可以进行下一个位置的迁移
boolean advance = true;
// 最后一个数据迁移的线程将该值置为true，并进行本轮扩容的收尾工作
boolean finishing = false;
// i标识桶索引, bound标识边界
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 每一次自旋前的预处理，主要是为了定位本轮处理的桶区间
// 正常情况下，预处理完成后：i == transferIndex-1：右边界
// bound == transferIndex-stride：左边界
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;
}
}
// 当前是处理最后一个tranfer任务的线程或出现扩容冲突
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {// 所有桶迁移均已完成
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 扩容线程数减1,表示当前线程已完成自己的transfer任务
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 判断当前线程是否是本轮扩容中的最后一个线程，如果不是，则直接退出
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
/**
* 最后一个数据迁移线程要重新检查一次旧table中的所有桶，看是否都被正确迁移到新table了：
* ①正常情况下，重新检查时，旧table的所有桶都应该是ForwardingNode;
* ②特殊情况下，比如扩容冲突(多个线程申请到了同一个transfer任务)，此时当前线程领取的任务会作废，那么最后检查时，
* 还要处理因为作废而没有被迁移的桶，把它们正确迁移到新table中
*/
i = n;
}
}
// 旧桶本身为null，不用迁移，直接尝试放一个ForwardingNode
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;
// 桶的hash>0，说明是链表迁移
if (fh >= 0) {
/**
* 下面的过程会将旧桶中的链表分成两部分：ln链和hn链
* ln链会插入到新table的槽i中，hn链会插入到新table的槽i+n中
*/
int runBit = fh & n;
// lastRun指向最后一个相邻runBit不同的结点
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;
}
// 以lastRun所指向的结点为分界，将链表拆成2个子链表ln、hn
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); // ln链表存入新桶的索引i位置
setTabAt(nextTab, i + n, hn); // hn链表存入新桶的索引i+n位置
setTabAt(tab, i, fwd); // 设置ForwardingNode占位
advance = true; // 表示当前旧桶的结点已迁移完毕
}
else if (f instanceof TreeBin) {
/**
* 下面的过程会先以链表方式遍历，复制所有结点，然后根据高低位组装成两个链表；
* 然后看下是否需要进行红黑树转换，最后放到新table对应的桶中
*/
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); // 设置ForwardingNode占位
advance = true; // 表示当前旧桶的结点已迁移完毕
}
}
}
}
}
}
扩容时的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) {
// 检查头结点，table[i]就是待查找的项，直接返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// hash值 < 0, 说明遇到特殊结点(非链表结点), 调用find()方法查找
else if (eh < 0)
// 调用节点对象的find方法查找值
return (p = e.find(h, key)) != null ? p.val : null;
// 如果上面都没有rentun，那么剩下的就是链表,遍历查找了
while ((e = e.next) != null) {
if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
多线程协助扩容
在 put 操作时，假设正在迁移扩容，正好有一个线程进来，想要 put 值到迁移的 Node上，怎么办？
在 put() 方法中调用了 helpTransfer() 方法
// put() 方法中的代码片段，帮助扩容
tab = helpTransfer(tab, f);
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// nextTab保存nextTable
if (tab != null && (f instanceof ForwardingNode) && (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 拿当前标的长度 获取 扩容标识戳 假设 16 -> 32 扩容：1000 0000 0001 1011
int rs = resizeStamp(tab.length);
// 条件一：nextTab == nextTable
// 成立：表示当前扩容正在进行中
// 不成立：1.nextTable被设置为Null 了，扩容完毕后，会被设为Null
// 2.再次出发扩容了...咱们拿到的nextTab 也已经过期了...
//条件二：table == tab
//成立：说明 扩容正在进行中，还未完成
//不成立：说明扩容已经结束了，扩容结束之后，最后退出的线程 会设置 nextTable 为 table
//条件三：(sc = sizeCtl) < 0
//成立：说明扩容正在进行中
//不成立：说明sizeCtl当前是一个大于0的数，此时代表下次扩容的阈值，当前扩容已经结束。
while (nextTab == nextTable && table == tab && (sc = sizeCtl) < 0) {
// 条件一：(sc >>> RESIZE_STAMP_SHIFT) != rs
// true->说明当前线程获取到的扩容唯一标识戳 非 本批次扩容
// false->说明当前线程获取到的扩容唯一标识戳 是 本批次扩容
// 条件二： JDK1.8 中有bug jira已经提出来了 其实想表达的是 = sc == (rs << 16 ) + 1
// true-> 表示扩容完毕，当前线程不需要再参与进来了
// false->扩容还在进行中，当前线程可以参与
// 条件三：JDK1.8 中有bug jira已经提出来了 其实想表达的是 = sc == (rs<<16) + MAX_RESIZERS
// 条件四：transferIndex <= 0
// true->说明map对象全局范围内的任务已经分配完了，当前线程进去也没活干..
// false->还有任务可以分配。
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
// sizeCtl加 1，表示多一个线程进来协助扩容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 扩容
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
10.扩容图解
触发扩容的操作：
假设目前数组长度为8，数组的元素的个数为5。再放入一个元素就会触发扩容操作。
总结一下扩容条件：
(1) 元素个数达到扩容阈值。
(2) 调用 putAll 方法，但目前容量不足以存放所有元素时。
(3) 某条链表长度达到8，但数组长度却小于64时。
CPU核数与迁移任务hash桶数量分配(步长)的关系
单线程扩容
多线程协助扩容
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ygju6BT1-1652189276511)(./多线程协助扩容.png)]](https://img-blog.csdnimg.cn/7ce5228fa664400b85811c9ed49d0b77.png)
链表迁移
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fXle6nov-1652189276511)(./链表扩容.png)]](https://img-blog.csdnimg.cn/8b045cbb107244f6bd38d7b5b8aa8f20.png)
首先锁住数组上的Node节点，然后和HashMap1.8中一样，将链表拆分为高位链表和低位链表两个部分，然后复制到新的数组中。
lastRun 节点
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1v0ZK7Iu-1652189276512)(红黑树迁移.png)]](https://img-blog.csdnimg.cn/cf93fcaf189341e7bacf3bc9c1da5ff6.png)
扩容前后如何处理存取请求?
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5WqmtLmF-1652189276512)(扩容前后如何处理存取请求.png)]](https://img-blog.csdnimg.cn/4bb6972ab86140cd815cfd4ca54f24bd.png)
多线程迁移任务完成后的操作
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZcmgH4cV-1652189276512)(并发迁移.png)]](https://img-blog.csdnimg.cn/bf51524b8f114121bd9479ab5834fa08.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dMOT1f0d-1652189276513)(分别迁移完成.png)]](https://img-blog.csdnimg.cn/5bc592ef2de040e19f130533d52ed6fa.png)
11.面试题
1. JDK1.8中的ConcurrentHashMap是如何保证线程安全的？
- 储存Map数据的数组时被volatile关键字修饰，一旦被修改，其他线程就可见修改。因为是数组存储，所以只有改变数组内存值是才会触发volatile的可见性
- 如果put操作时hash计算出的槽点内没有值，采用自旋+CAS保证put一定成功，且不会覆盖其他线程put的值
- 如果put操作时节点正在扩容，即发现槽点为转移节点，会等待扩容完成后再进行put操作，保证扩容时老数组不会变化
- 对槽点进行操作时会锁住槽点，保证只有当前线程能对槽点上的链表或红黑树进行操作
- 红黑树旋转时会锁住根节点，保证旋转时线程安全
2. 扩容期间在未迁移到的hash桶插入数据会发生什么？
答：只要插入的位置扩容线程还未迁移到，就可以插入，当迁移到该插入的位置时，就会阻塞等待插入操作完成再继续迁移 。
3.正在迁移的hash桶遇到 get 操作会发生什么？
答：在扩容过程期间形成的 hn 和 ln链 是使用的类似于复制引用的方式，也就是说 ln 和 hn 链是复制出来的，而非原来的链表迁移过去的，所以原来 hash 桶上的链表并没有受到影响，因此如果当前节点有数据，还没迁移完成，此时不影响读，能够正常进行。
如果当前链表已经迁移完成，那么头节点会被设置成fwd节点，此时get线程会帮助扩容。
4.正在迁移的hash桶遇到 put/remove 操作会发生什么？
如果当前链表已经迁移完成，那么头节点会被设置成fwd节点，此时写线程会帮助扩容，如果扩容没有完成，当前链表的头节点会被锁住，所以写线程会被阻塞，直到扩容完成。
5.并发情况下，各线程中的数据可能不是最新的，那为什么 get 方法不需要加锁？
答：get操作全程不需要加锁是因为Node的成员val是用volatile修饰的，在多线程环境下线程A修改结点的val或者新增节点的时候是对线程B可见的
6.ConcurrentHashMap 和 Hashtable 的区别?
ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。
底层数据结构：
JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable是采用 数组+链表 的形式。
实现线程安全的方式（重要）： ① 在JDK1.7的时候，ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。② Hashtable(同一把锁) :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。
7.ConcurrentHashMap 和 HashMap 的相同点和不同点
相同之处：
都是数组 +链表+红黑树的数据结构（JDK8之后），所以基本操作的思想一致
都实现了Map接口，继承了AbstractMap 操作类，所以方法大都相似，可以相互切换
不同之处：
ConcurrentHashMap 是线程安全的，多线程环境下，无需加锁直接使用
ConcurrentHashMap 多了转移节点，主要用户保证扩容时的线程安全
8.扩容过程中，读访问能否访问的到数据？怎么实现的？
可以的。当数组在扩容的时候，会对当前操作节点进行判断，如果当前节点还没有被设置成fwd节点，那就可以进行读写操作，如果该节点已经被处理了，那么当前线程也会加入到扩容的操作中去。
9.为什么超过冲突超过8才将链表转为红黑树而不直接用红黑树?
默认使用链表， 链表占用的内存更小
正常情况下，想要达到冲突为8的几率非常小，如果真的发生了转为红黑树可以保证极端情况下的效率
10.ConcurrentHashMap 和HashMap的扩容有什么不同？
HashMap的扩容是创建一个新数组，将值直接放入新数组中，JDK7采用头链接法，会出现死循环，JDK8采用尾链接法，不会造成死循环
ConcurrentHashMap 扩容是从数组队尾开始拷贝，拷贝槽点时会锁住槽点，拷贝完成后将槽点设置为转移节点。所以槽点拷贝完成后将新数组赋值给容器
11.ConcurrentHashMap 是如何发现当前槽点正在扩容的？
ConcurrentHashMap 新增了一个节点类型，叫做转移节点，当我们发现当前槽点是转移节点时（转移节点的 hash 值是 -1），即表示 Map 正在进行扩容.
12.描述一下 CAS 算法在 ConcurrentHashMap 中的应用
CAS是一种乐观锁，在执行操作时会判断内存中的值是否和准备修改前获取的值相同，如果相同，把新值赋值给对象，否则赋值失败，整个过程都是原子性操作，无线程安全问题
ConcurrentHashMap 的put操作是结合自旋用到了CAS，如果hash计算出的位置的槽点值为空，就采用CAS+自旋进行赋值，如果赋值是检查值为空，就赋值，如果不为空说明有其他线程先赋值了，放弃本次操作，进入下一轮循环
现的？
可以的。当数组在扩容的时候，会对当前操作节点进行判断，如果当前节点还没有被设置成fwd节点，那就可以进行读写操作，如果该节点已经被处理了，那么当前线程也会加入到扩容的操作中去。
9.为什么超过冲突超过8才将链表转为红黑树而不直接用红黑树?
默认使用链表， 链表占用的内存更小
正常情况下，想要达到冲突为8的几率非常小，如果真的发生了转为红黑树可以保证极端情况下的效率
10.ConcurrentHashMap 和HashMap的扩容有什么不同？
HashMap的扩容是创建一个新数组，将值直接放入新数组中，JDK7采用头链接法，会出现死循环，JDK8采用尾链接法，不会造成死循环
ConcurrentHashMap 扩容是从数组队尾开始拷贝，拷贝槽点时会锁住槽点，拷贝完成后将槽点设置为转移节点。所以槽点拷贝完成后将新数组赋值给容器
11.ConcurrentHashMap 是如何发现当前槽点正在扩容的？
ConcurrentHashMap 新增了一个节点类型，叫做转移节点，当我们发现当前槽点是转移节点时（转移节点的 hash 值是 -1），即表示 Map 正在进行扩容.
12.描述一下 CAS 算法在 ConcurrentHashMap 中的应用
CAS是一种乐观锁，在执行操作时会判断内存中的值是否和准备修改前获取的值相同，如果相同，把新值赋值给对象，否则赋值失败，整个过程都是原子性操作，无线程安全问题
ConcurrentHashMap 的put操作是结合自旋用到了CAS，如果hash计算出的位置的槽点值为空，就采用CAS+自旋进行赋值，如果赋值是检查值为空，就赋值，如果不为空说明有其他线程先赋值了，放弃本次操作，进入下一轮循环
8627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
