transfer()
package leetcode0606.JUC.ConcurrentHashMap;
import java.util.concurrent.ConcurrentHashMap;
import static leetcode0606.JUC.ConcurrentHashMap.BasicMethod.resizeStamp;
import static leetcode0606.JUC.ConcurrentHashMap.filed.MOVED;
import static leetcode0606.JUC.ConcurrentHashMap.filed.NCPU;
public class _transfer {
private final void transfer(ConcurrentHashMap.Node<K,V>[] tab, ConcurrentHashMap.Node<K,V>[] nextTab) {
// n 表示扩容之前的table的长度
// stride 表示分配给线程任务的步长，即给当前线程分配好几个桶，而不是一个一个去分配
int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
// stride = 16
stride = MIN_TRANSFER_STRIDE; // subdivide range
// nextTab == null 代表当前线程是触发扩容的线程
// 往下看，nextTab指向了新的引用，当别的线程进来，发现nextTab不为null
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
// 新表的长度扩为2倍
ConcurrentHashMap.Node<K,V>[] nt = (ConcurrentHashMap.Node<K,V>[])new ConcurrentHashMap.Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
// 赋值给对象属性 nextTable ,方便协助扩容线程 拿到新表
nextTable = nextTab;
// transferIndex 记录迁移数据整体进度（位置）的标记
transferIndex = n;
}
int nextn = nextTab.length;
// fwd节点，当某个桶位的数据处理完毕后，将此桶位设置为fwd节点，其它写线程，或读线程看到后，会有不同逻辑
ConcurrentHashMap.ForwardingNode<K,V> fwd = new ConcurrentHashMap.ForwardingNode<K,V>(nextTab);
// 推进标记
boolean advance = true;
// 完成标记
boolean finishing = false; // to ensure sweep before committing nextTab
//自旋
/*
i 分配给当前线程任务所执行到的桶位（即当前线程干到哪了）
bound 分配给当前线程任务的下界限制
*/
for (int i = 0, bound = 0;;) {
/*
f 头节点
fh 头节点的哈希值
*/
*/
ConcurrentHashMap.Node<K,V> f; int fh;
============================================================？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
/*
1.给当前线程分配任务区间
2.维护当前线程任务进度(i表示当前处理的桶位)
3.维护map对象全局范围内的进度
*/
while (advance) {
/*
nextIndex 分配任务的开始下标
nextBound 分配任务的结束下标
*/
int nextIndex, nextBound;
/*
CASE1:
条件一：--i >= bound
true 当前线程的任务尚未完成，还有相应的区间的桶位要处理，--i就让当前线程处理下一个桶位
false 当前线程任务已完成，或者 未分配
finishing
*/
if (--i >= bound || finishing)
advance = false;
/*
CASE2: 前置条件---当前线程任务已完成或者未分配
(nextIndex = transferIndex) <= 0)
true 表示对象全局范围内的桶位都分配完毕了，没有区间可分配了,
设置当前线程的i变量为-1,跳出循坏后，执行退出迁移任务相关的程序
false 表示对象全局范围内的桶位尚未分配完毕，还有区间可以分配
*/
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
/*
CASE3: 前置条件----当前线程需要分配任务，全局范围内还有数据尚未迁移
条件成立：当前线程分配任务成功
条件失败：当前线程分配任务失败，和其它线程竞争失败
*/ ??????????
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// point 1
// 处理线程完成任务后，线程退出transfer()方法的逻辑
/*
条件一：i < 0
true 此时i=-1，表示当前线程未分配到任务（干完了或者没分配）
i >= n || i + n >= nextn 不可能成立
*/
if (i < 0 || i >= n || i + n >= nextn) {
int sc; // sizeCtl
// 144行设置成功后，在进入到这里来，做后续工作
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1); // sizeCtl = 0.75 * 2n 即扩容后的阈值
return;
}
// CAS成功-----线程数-1，当前线程退出
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// (sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT
// true 当前线程不是最后一个退出的任务
// false 当前线程是最后一个退出的线程
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 最后一个退出的线程 更新以下数据
finishing = advance = true;
i = n; // recheck before commit
}
}
//=======================================================================
// 线程处理一个桶位数据的迁移工作，处理完毕后advance=true表示继续推进，然后自旋
/*
poit 2-4 的前置条件:当前线程任务尚未处理完，正在进行中。
*/
//========================================================================
// point2
// 判断是否为null节点
else if ((f = tabAt(tab, i)) == null)
//将此空头节点指向一个fwd节点
advance = casTabAt(tab, i, null, fwd);
// point3
// 当前同为已经迁移过了，不需要处理了，然后再次更新当前线程任务索引，再次处理下一个桶位或者其它。
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
// point4
// 当前桶位有数据，且数据需要迁移
else {
// 上锁，锁的粒度是当前桶位的头节点
synchronized (f) {
// 防止其它线程已经把头节点改了，所以进行双重检查
if (tabAt(tab, i) == f) {
ConcurrentHashMap.Node<K,V> ln, hn;
// ln 低位链表的引用
// hn 高位链表的引用
// 当前头节点 是 链表
if (fh >= 0) {
// lastRun 机制 ？？？？？？？？？？？？？？
// runBit 可以 获取 当前链表 末尾连续高位不变的node，为了便于迁移链表
int runBit = fh & n;
ConcurrentHashMap.Node<K,V> lastRun = f;
for (ConcurrentHashMap.Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
// runBit == 0 说明lastRun引用的链表为低位链表,就让ln指向低位链表
if (runBit == 0) {
ln = lastRun;
hn = null;
}
// runBit == 1 说明lastRun引用的链表为高位链表,就让hn指向高位链表
else {
hn = lastRun;
ln = null;
}
// 迭代链表，跳出条件：当前节点为lastRun
// 构建 ln,hn节点
for (ConcurrentHashMap.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 ConcurrentHashMap.Node<K,V>(ph, pk, pv, ln);
else
hn = new ConcurrentHashMap.Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
==============================================================================
// 当前桶位头节点为TreeBin
else if (f instanceof ConcurrentHashMap.TreeBin) {
// 转换头节点为treeBin引用 t
ConcurrentHashMap.TreeBin<K,V> t = (ConcurrentHashMap.TreeBin<K,V>)f;
// 低位双向链表---- lo 指向低位链表的头 loTail 指向低位链表的尾巴
ConcurrentHashMap.TreeNode<K,V> lo = null, loTail = null;
// 高位双向链表---- hi 指向高位链表的头 hiTail 指向高位链表的尾巴
ConcurrentHashMap.TreeNode<K,V> hi = null, hiTail = null;
// lc 表示低位链表元素数量
// hc 表示高位链表元素数量
int lc = 0, hc = 0;
// 迭代TreeBin中的双向链表，从头结点 到 尾节点
for (ConcurrentHashMap.Node<K,V> e = t.first; e != null; e = e.next) {
//
int h = e.hash;
// 使用当前节点 构建出 新节点
ConcurrentHashMap.TreeNode<K,V> p = new ConcurrentHashMap.TreeNode<K,V>
(h, e.key, e.val, null, null);
// (h & n) == 0 加入到低位链
if ((h & n) == 0) {
// (p.prev = loTail) == null 说明当前低位链表还没有数据
if ((p.prev = loTail) == null)
lo = p;
// 低位链表有数据，此时当前元素追加到低位链表的末尾
else
loTail.next = p;
// 将低位链表尾指针 指向 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 ConcurrentHashMap.TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new ConcurrentHashMap.TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
}
helpTransfer()
package leetcode0606.JUC.ConcurrentHashMap;
import java.util.concurrent.ConcurrentHashMap;
public class _helpTransfer {
final ConcurrentHashMap.Node<K,V>[] helpTransfer(ConcurrentHashMap.Node<K,V>[] tab, ConcurrentHashMap.Node<K,V> f) {
// nextTab 引用的是 fwd。nextTable == map.nextTable 理论上是这样的
// sc sizeCtl的引用
ConcurrentHashMap.Node<K,V>[] nextTab; int sc;
/*
条件一：tab != null恒成立
条件二：f instanceof ConcurrentHashMap.ForwardingNode 恒成立
条件三：(nextTab = ((ConcurrentHashMap.ForwardingNode<K,V>)f).nextTable) != null)恒成立，在transfer()中创建。
*/
if (tab != null && (f instanceof ConcurrentHashMap.ForwardingNode) &&
(nextTab = ((ConcurrentHashMap.ForwardingNode<K,V>)f).nextTable) != null) {
// 拿到 扩容唯一 标识戳
// 16-->32
//
int rs = resizeStamp(tab.length);
/*
条件一:nextTab == nextTable
true 表示正在进行扩容
false 表示nextTable=null ，表示已经扩容完成了 或者 再次触发扩容了，拿到的nextTab过期了
条件二：table == tab
true 扩容正在进行中，还未完成
false 扩容已经完成了，扩容结束后，最后退出的那个线程会设置nextTable 为 table
条件三：(sc = sizeCtl) < 0)
true 扩容还在进行中
false sizeCtl>0 代表下次扩容阈值，当前扩容已经结束
*/
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
/*
条件一：(sc >>> RESIZE_STAMP_SHIFT) != rs 检查标尺戳使得否为对应的扩容
条件二： sc == (rs << 16) + 1
true 标识扩容完毕了，当前线程不需要再参与了 ， 因为sc低16位是 1+nThread
false 还在进行中，可以参与
条件三: sc == (rs << 16)+ MAX_RESIZERS .....
条件四: transferIndex <= 0
true 说明map对象全局范围内的任务已经分配完了，当前线程进去也没活干了，所以直接break
false 还有任务可以分配
*/
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;
}
}
800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
