1.前言
这部分主要讲解 put 方法中涉及到的一些定义
1.1 ForwardingNode
ForwardingNode 是一种临时节点类，在 ConcurrentHashMap 扩容中才会出现，它的hash值固定为-1，并且它不存储实际的数据数据。如果旧数组的一个hash桶中全部的节点都迁移到新数组中，旧数组就在这个hash桶中放置一个ForwardingNode。它的nextTable 用来指向新数组的位置 。 读操作或者迭代读时碰到ForwardingNode时，将操作转发到扩容后的新的table数组上去执行，写操作碰见它时，则尝试帮助扩容。
/**
* A node inserted at head of bins during transfer operations.
*/
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
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;
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;
}
}
}
}
1.2 部分属性详解
/*
* Encodings for Node hash fields. See above for explanation.
*/
// 表示当前对象是一个 ForwardingNode
static final int MOVED = -1; // hash for forwarding nodes
// 表示当前位置是一个 红黑树的root节点
static final int TREEBIN = -2; // hash for roots of trees
// ReservationNode的hash值
static final int RESERVED = -3; // hash for transient reservations
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
2. put 方法源码分析
public V put(K key, V value) {
// 这里调用的也是 putval 方法，与hashMap 不同的是它只有三个参数
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
// key : 插入的key
// value : 插入的value
// onlyIfAbsent: 如果为true则存在旧值时不会覆盖
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 这里不允许 key 和 value 为null.
if (key == null || value == null) throw new NullPointerException();
// 计算最终的hash值，详解见下
int hash = spread(key.hashCode());
int binCount = 0;
// 循环tab ，无退出条件只能内部退出
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 这里判断当 tab == null 或当 tab的长度为0 时
if (tab == null || (n = tab.length) == 0)
// 调用 initTable()方法，详解见 2.1，而hashmap 在这里调用的是resize()方法
tab = initTable();
/**
* tabAt(): 底层调用的是 ： (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
* getObjectVolatile：从内存中获取该对象的最新值（保证了可见性）
* 获取 当前插入元素应该放在数组的索引记为i, 获取数据索引为i的地方有没有元素
*/
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
/**
* 这里是数组在该索引下 元素为null，就会调用 casTabAt 原子性的尝试插入，
* 当没有别的线程使用这部分的资源就是，修改成功，否则失败
* 这样做也就达到了分段锁的效果
* casTabAt： 底层调用的也是 compareAndSwapObject，原理同 2.2 compareAndSwapInt
*/
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
// 插入成功，跳出循环
break; // no lock when adding to empty bin
}
// 走到这里说明 数组在该索引下的元素不为null,记为f,
// 当满足这个条件时，说明当前table 正在扩容
else if ((fh = f.hash) == MOVED)
// 如果正在扩容 则帮助它扩容，详解见 2.3
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 这里 f已经获取了 tab在索引为 (n - 1) & hash（记为i，这也是当前元素要插入的索引） 位置的元素
// 给 f 加把锁
synchronized (f) {
// 再次判断 tab 在索引为 i 的位置上 元素与 f 相等，防止加锁过程前其他线程修改过f的值
if (tabAt(tab, i) == f) {
// fh >= 0 ,表示 f是一个链表结构
if (fh >= 0) {
// binCount : 记录f中的 元素个数
binCount = 1;
// 遍历 f，寻找插入位置
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;
// 进入到这里说明 e的key 和要插入的可以 是相同的，根据 onlyIfAbsent 决定要不要对旧值进行覆盖
if (!onlyIfAbsent)
e.val = value;
// 跳出循环
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
// 走到这里说明，f中没有元素key 和当前插入元素的key 相同，所以直接使，f的尾节点的next 指向当前插入的元素即可
pred.next = new Node<K,V>(hash, key,
value, null);
// 跳出循环
break;
}
}
}
// 这里是当f 是一个红黑树结构时
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
// putTreeVal：若插入成功返回null,否则返回和当前被插入元素的key相同的元素
// 这里它的原理和hashMap中的原理类似，我贴下HashMap的链接 https://juejin.cn/post/7041109276881846280/
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
// 进入到这里说明 e的key 和要插入的可以 是相同的，根据 onlyIfAbsent 决定要不要对旧值进行覆盖
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// 判断当 binCount >= 8时，会把当前链表结构转成红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
// 当 oldVal != null，说明元素数量未发生改变 直接返回，此时已插入完成
return oldVal;
// 新插入的元素，元素数量发生改变 退出循环
break;
}
}
}
// 走到这里说明元素数量发生改变，调用 addCount，使其binCount+1，并检查其是否需要扩容
addCount(1L, binCount);
return null;
}
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
static final int spread(int h) {
// h 与 h左移16位先进行异或运算，然后在于HASH_BITS进行与运算，得出最终hash值
return (h ^ (h >>> 16)) & HASH_BITS;
}
2.1 initTable() 方法详解
主要作用： 初始化当前 ConcurrentHashMap 中的 table
/**
* Initializes table, using the size recorded in sizeCtl.
*/
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) { //当 table ==null时，或table的长度为0时，进行初始化操作。
if ((sc = sizeCtl) < 0) // 当sc=-1， 表示当前table 正在初始化中，当 sc=-n/2时，表示table正在扩容
// 这里表示已经有线程在进行初始化了，让当前线程让步等待
// 这个方法表示，让当前线程退出cpu的时间片，使其运行态变为就绪态，重新竞争cpu
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { // 通过cas方法，判断当前线程是否需要创建。 compareAndSwapInt：详解见2.2。
try {
// 当table == null 或 table的长度为0时，进行初始化
if ((tab = table) == null || tab.length == 0) {
// 如果有指定sizeCtl的值就借用，否则用 DEFAULT_CAPACITY：16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 创建一个长度为 n Node<K,V>数组
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
// 把它赋给table
table = tab = nt;
// 设置一下sc的值
sc = n - (n >>> 2);
}
} finally {
// 把sc 赋给 sizeCtl
sizeCtl = sc;
}
break;
}
}
// 返回，创建完成
return tab;
}
2.2 compareAndSwapInt
主要作用：原子性比较并交换，基于CAS思想的 native 方法
// sun.misc.Unsafe#compareAndSwapInt
// 读取传入对象 var1 在内存中偏移量为 var2 位置的值与期望值 var4 作比较。
// 相等就把 var5 值赋值给 var2 位置的值。方法返回true。
// 不相等，就取消赋值，方法返回false。 用于保证并发修改的安全性
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
2.3 helpTransfer 源码分析 参考：blog.csdn.net/lxsxkf/arti…
主要作用：判断当前线程是否需要协助扩容，如果需要进行扩容操作，否则直接返回
/**
* Helps transfer if a resize is in progress.
*/
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 当table 不为null 且 f是 ForwardingNode 类型时 且 f.nextTable 不为null
// 这里用 nextTab 保存新table的引用
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 主要是通过这个方法生成一个扩容戳 ，详解见 2.4
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;
// 通过cas 原子性判断，当条件满足时 进入扩容操作
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
// 扩容操作，详解见 2.5
transfer(tab, nextTab);
// 扩容后跳出循环
break;
}
}
// 返回扩容后的 nextTab
return nextTab;
}
// 无需扩容 直接返回 table
return table;
}
2.4 resizeStamp 源码分析
主要作用：ConcurrentHashMap 在扩容过程中生成一个唯一的扩容戳。
/**
* Returns the stamp bits for resizing a table of size n.
* Must be negative when shifted left by RESIZE_STAMP_SHIFT.
*/
static final int resizeStamp(int n) {
// RESIZE_STAMP_BITS ： 16
// 通过n的前导0的个数 与 （15 左移1位）后进行或运算 返回结果。
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
// 求i的前导0的个数
public static int numberOfLeadingZeros(int i) {
// HD, Figure 5-6
if (i == 0)
return 32;
int n = 1;
if (i >>> 16 == 0) { n += 16; i <<= 16; }
if (i >>> 24 == 0) { n += 8; i <<= 8; }
if (i >>> 28 == 0) { n += 4; i <<= 4; }
if (i >>> 30 == 0) { n += 2; i <<= 2; }
n -= i >>> 31;
return n;
}
2.5 transfer 源码分析
主要作用：ConcurrentHashMap 中用来扩容的方法，原理和hashMap 扩容的原理类似，但该方法支持并发操作，所以实现略微复杂。
/**
* Moves and/or copies the nodes in each bin to new table. See
* above for explanation.
* tab: 扩容前的数组
* nextTab： 扩容后的数组
* 这里主要是进行数据转移
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
// 获取扩容前的数组长度 记为 n; stride : 每个cpu所需要处理的桶个数
int n = tab.length, stride;
//将 (n>>>3相当于 n/8) 然后除以 CPU核心数。如果得到的结果小于 16，那么就使用 16
// 这里的目的是让每个 CPU 处理的桶一样多，避免出现转移任务不均匀的现象，如果桶较少的话，默认一个 CPU（一个线程）处理 16 个桶，也就是长度为16的时候，扩容的时候只会有一个线程来扩容
/** Number of CPUS, to place bounds on some sizings
static final int NCPU = Runtime.getRuntime().availableProcessors();
*/
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// 当nextTab 为null时 ，则先进行初始化
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
// 这里初始化后的容量是原先的两倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
// 把初始化后的数组 赋给 nextTab
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
// 这里抛异常可能是因为 n << 1 > Integer.MAX_VALUE,会被解析成一个负数，导致初始化异常
// 所以 直接把Integer.MAX_VALUE 赋给 sizeCtl
sizeCtl = Integer.MAX_VALUE;
return;
}
// 更新一下它的成员变量
nextTable = nextTab;
// 转移的索引下标，也更新一下成员变量
transferIndex = n;
}
// 记录更新后的数组长度
int nextn = nextTab.length;
// 因为在扩容，所以创建一个 ForwardingNode 实例，使其nextTable 指向 扩容后的数组，并且它的hash值为-1
// 这也是前面我们讲put 方法中提过的，别的线程，可以根据它找到扩容后数组的原因
// 这里也相当于一个占位，表示这个索引对应的地方已经有线程在更新了。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 标识符 首次推进为 true，如果等于 true，说明需要再次推进一个下标（i--），反之，如果是 false，那么就不能推进下标，需要将当前的下标处理完毕才能继续推进
boolean advance = true;
// 标识符，标识是否已完成
boolean finishing = false; // to ensure sweep before committing nextTab
// 通过for自循环处理每个槽位中的链表元素，默认advace为真，通过CAS设置transferIndex属性值，
// 并初始化i和bound值，i指当前处理的槽位序号，bound指需要处理的槽位边界，先处理槽位15的节点；
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 因为前面默认是true ，首次进入while 循环会跳到第一个 else if 给 nextIndex 赋值
// 在前面已经完成对 transferIndex 的赋值，即扩容前数组的长度 n
while (advance) {
int nextIndex, nextBound;
// 首次进入 i=0 , finishing =false,继续向下执行
if (--i >= bound || finishing)
advance = false;
// 给 nextIndex 赋值 赋值后仍不满足条件，继续向下执行
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 通过cas 比较交换算法，详解见 2.2
// 这里就是读取 this对象 在内存中偏移量为 TRANSFERINDEX 的值 是不是nextIndex，如果是就把修改后的 nextBound 的值，设置给它
// TRANSFERINDEX = U.objectFieldOffset(k.getDeclaredField("transferIndex")); 它在静态代码块中 就是获取 对象K的 transferIndex 属性的偏移量 ，这里保证的是再次过程中没有别的线程修改过这地方的值。
// stride: 每个cpu所需要处理的桶个数，这里即划分了每个cpu处理的桶的区间
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
// 记录处理的开始区间
bound = nextBound;
// 结束区间
i = nextIndex - 1;
advance = false;
}
}
// 当i<0 时 表示当前线程需要处理的的区间，已经处理结束
// i >= n 当前处理的范围大于旧链表最大长度，已经不需要拷贝越界数据
// i + n >= nextn 。nextn表示新哈希表长度，如果当前长度超过新哈希表长度，证明是不合法的
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 当 finishing 为 true 时，表示它的迁移工作已完成
if (finishing) {
// 把 nextTable 置为null
nextTable = null;
// 迁移后的新表 赋给 table
table = nextTab;
// 设置当容量达到新表长度的75%时 扩容
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 这里使用 CAS 操作对 sizeCtl 的低16位进行减 1，代表做完了属于自己的任务
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//第一个扩容的线程，执行transfer方法之前，会设置 sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)
//后续帮其扩容的线程，执行transfer方法之前，会设置 sizeCtl = sizeCtl+1
//每一个退出transfer的方法的线程，退出之前，会设置 sizeCtl = sizeCtl-1
//那么最后一个线程退出时：必然有
//sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT
// 如果 sc - 2 不等于标识符左移 16 位。如果他们相等了，说明没有线程在帮助他们扩容了。也就是说，扩容结束了。这个时候可以直接return
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 走到这里说明 当前线程扩容结束
finishing = advance = true;
// 再循环检查一次
i = n; // recheck before commit
}
}
// 这里主要作用是 获取数组索引为i 处的元素 把它赋给f，如果为null ，就把前面新建的 fwd 放到里面去
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// static final int MOVED = -1;
// 这里当它的hash == -1 表示这个地方已经有别的线程处理过了，直接把advance 置为true
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 此时 f已经获取到了 数组索引为i 处的元素
// 走到这里说明就是当前线程 负责处理hash桶 移动到新的hash表中去
// 锁住首节点
synchronized (f) {
// 这里是再次判断一下，判断 数组索引为i的元素是否还是 f
// 防止在获取锁的时候，f被别的线程改过，保证线程安全
if (tabAt(tab, i) == f) {
// ln：放在低位索引的节点（即索引位置与原先旧表索引相同）
// hn：放在高位索引的节点（索引位置 n+x)
Node<K,V> ln, hn;
// 当 fh >= 0 表明这个地方存贮的元素是一个链表结构
if (fh >= 0) {
// 这部分中的代码逻辑 和hashMap 中挺像的
// n是 旧表的长度（2的n次幂) 所以它的形式为 10，100，1000...这种
// fh 是 f节点的hash 值，所以 fh&n 值只有 0 或 n
// 当值为 0 时，表示此元素在新的数组中的索引和原先在旧数组中的索引是一样的
// 当值为n时 元素在新哈希表中的 x+n 位置上。（x为当前哈希表数组下标所在位置）
int runBit = fh & n;
// 定义 lastRun ：用来记录链表中某个节点及其之后节点的hash值全部相同的节点，先把f赋给它，处理只有一个节点的情况
Node<K,V> lastRun = f;
// 遍历节点 f
//这个地方跟hashmap不同，hashmap是直接推进到链表尾
//这个地方的处理在于想保留链表后所有hash值计算相同的点，这些点可以重复利用，不需要重新new
//所以下边需要获取哪个节点后的hash值全部相同
for (Node<K,V> p = f.next; p != null; p = p.next) {
// 取出当前节点的hash
int b = p.hash & n;
// 如果他不等于 runBit,则把 b赋给 runBit，把p赋给 lastRun
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
// 如果runBit == 0,说明 lastRun 记录的节点需要放在低位索引上
if (runBit == 0) {
ln = lastRun;
hn = null;
}
// 否则的话 说明 lastRun 记录的节点需要放在高位索引上
else {
hn = lastRun;
ln = null;
}
// 这里再次 遍历p,处理lastRun 节点之前未处理的节点
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
// (ph & n) == 0 ：前面已经说过 ，这表示放在低位索引上
if ((ph & n) == 0)
// 重新设置 ln,新建一个 Node 使其next指向 原先的ln
ln = new Node<K,V>(ph, pk, pv, ln);
else
// 否则的话放在高位节点。同上类似
hn = new Node<K,V>(ph, pk, pv, hn);
}
// 原子性设置 nextTab（新表）索引为i的地方，元素设为 ln
setTabAt(nextTab, i, ln);
// 原子性设置 nextTab（新表）索引为i+n的地方，元素设为 hn
setTabAt(nextTab, i + n, hn);
// 设置旧表 索引为i的地方 元素为 fwd;
setTabAt(tab, i, fwd);
//设置advance为true让当前线程继续计算处理其他旧哈希桶位置的拷贝
advance = true;
}
// 否则的话 判断当它是一个 TreeBin（即这里是红黑树结构) 类型时
else if (f instanceof TreeBin) {
// 先把 节点f转成 TreeBin结构，记为t
TreeBin<K,V> t = (TreeBin<K,V>)f;
// lo: 低位头节点 ，loTail:低位尾节点
TreeNode<K,V> lo = null, loTail = null;
// ho：高位头节点；hoTail：高位尾节点
TreeNode<K,V> hi = null, hiTail = null;
// lc:记录低位红黑树元素个数; hc:记录高位红黑树元素个数
int lc = 0, hc = 0;
// 遍历节点 t
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
// 根据元素的 hash,key，value 新建一个 TreeNode节点
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
// (h & n) == 0 ：表示放在低位索引上
if ((h & n) == 0) {
// 当 loTail == null，表明这是第一次赋值
if ((p.prev = loTail) == null)
// 所以把 p 赋给元素头节点
lo = p;
else
// 否则的话，使 loTail.next = p
loTail.next = p;
// 最后把 loTail 设为 p
loTail = p;
// 计数加1
++lc;
}
// 否则的话，说明他会放到高位索引
else {
// 这部分逻辑和上面类似，第一次赋给头节点，后面给尾节点赋值
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
// 计数加1
++hc;
}
}
// static final int UNTREEIFY_THRESHOLD = 6;
// 这里会判断，当当前红黑树中的元素数量小于等于 6时，会取消树化，
// 即由红黑树结构变成链表结构，
// 否则的话，判断当hc == 0时，说明t中所有元素都放在低位索引，直接把t赋给 ln
// 否则的话，则直接根据lo 新建一个 TreeBin 赋给 ln
// untreeify(lo)：取消树华，详解见 2.8
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;
// 把ln 赋给 nextTab 索引为i的元素
setTabAt(nextTab, i, ln);
// 把 hn 赋给 nextTab，索引为 i+n 的元素
setTabAt(nextTab, i + n, hn);
// 设置旧表 索引为i的地方 元素为 fwd;
setTabAt(tab, i, fwd);
//设置advance为true让当前线程继续计算处理其他旧哈希桶位置的拷贝
advance = true;
}
}
}
}
}
}
2.6 tabAt() 源码分析
/**
* tabAt(): 底层调用的是 ： (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
* getObjectVolatile：从内存中获取该对象的最新值（保证了可见性）
* 获取 当前插入元素应该放在数组的索引记为i, 获取数据索引为i的地方有没有元素
*/
@SuppressWarnings("unchecked")
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);
}
2.7 casTabAt() 源码分析
/**
* 这里是数组在该索引下 元素为null，就会调用 casTabAt 原子性的尝试插入，
* 当没有别的线程使用这部分的资源就是，修改成功，否则失败
* 这样做也就达到了分段锁的效果
* casTabAt： 底层调用的也是 compareAndSwapObject，原理同 2.2 compareAndSwapInt
*/
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
2.8 untreeify() 源码分析
主要作用：由红黑树结构转成链表结构
static <K,V> Node<K,V> untreeify(Node<K,V> b) {
// hd：头节点 ， tl：尾节点
Node<K,V> hd = null, tl = null;
// 遍历节点 b
for (Node<K,V> q = b; q != null; q = q.next) {
// 根据节点 q 新建一个节点 p
Node<K,V> p = new Node<K,V>(q.hash, q.key, q.val, null);
// 第一次循环，头节点为null，先赋给头节点
if (tl == null)
hd = p;
// 后续每次循环都使尾节点的next指向它
else
tl.next = p;
// 把它赋给尾节点，继续遍历
tl = p;
}
// 返回头节点
return hd;
}
