多线程状态流转
HashMap底层原理
hashmap底层原理 从key = 1, 一直put 到13
1.默认初始化负载因子默认0.75
2.第一个元素put，判断Node<K,V>[] table，是否是空的，空的，调用resize(),扩容
3.扩容的时候先把扩容前的table复制一份，初始化16的大小的table，下次需要扩容的大小16 * 0.75 = 12，如果添加元素大于12了，就扩容(++size > threshold
)
4.看扩容前是否有元素，没有元素，直接返回扩容好的对象
5.经过(p = tab[i = (n - 1) & hash]) == null，发现没有冲突。hash是key经过hash算法得到的一个值
6.直接赋值tab[i] = newNode(hash, key, value, null);
7.当元素key put 到13的时候，会产生 冲突 tab大小是16 key = 13产生冲突。。。(p = tab[i = (n - 1) & hash]) != null 了
8.p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))
8.1现有结点和插入结点的hash一致，key的地址一致，key的内容一致，代表2个相同的key做put操作，会把value值用后来的覆盖先put的
8.2如果现有结点的类型是树结点(p instanceof TreeNode), e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
8.3不同的key导致的冲突，进入死循环，
8.3.1如果冲突的结点的下一个结点是null,把要插入的key value 封装成Node阶段，赋值给冲突结点的下一个结点，如果冲突的元素是第8个元素，执行treeifyBin(tab, hash); 将连表变成树
8.3.2如果冲突结点的连表中有和插入结点的hash一致，key的地址一致，key的内容一致，代表2个相同的key做put操作，会把value值用后来的覆盖先put的
Hashmap底层原理 扩容流程
1.扩容后原容器不空
2.循环原容易的大小的次数
3.依次获取元素，(e = oldTab[j]) != null，垃圾回收旧元素 oldTab[j] = null;
3.1元素没有冲突，e.next == null，给对应的新元素赋值，newTab[e.hash & (newCap - 1)] = e;
不怕hash冲突的原因：引用文章: https://blog.csdn.net/u010425839/article/details/106620440/
3.2如果，e instanceof TreeNode,,,,,((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
3.3元素是链表结构， 引用文章https://segmentfault.com/a/1190000015812438
3.3.1定义2个链表 hi 和 lo链表
3.3.2如果(e.hash & oldCap) == 0，向lo链表中添加元素
3.3.3如果(e.hash & oldCap) == 1，向hi链表中添加元素
4.循环结束
5.lo链表不空，把lo链表放入到原数组的位置。newTab[j] = loHead;
6.hi链表不空，把hi链表放入到原数组 + 原数组长度的位置。newTab[j + oldCap] = hiHead
ConcurrentHashMap底层原理
1.开启多个线程同时put
2.计算hash，1. spread(key.hashCode()); 2. (h ^ (h >>> 16)) & HASH_BITS;
2.1调用hash函数，获取hash值，把hash值右移16位，再把结果值按位抑或移动前的hash值，在按位与0x7fffffff
3.死循环，判断tab是否已初始化，(tab == null || (n = tab.length) == 0)
3.1没有初始化，进入tab = initTable();
4. ((f = tabAt(tab, i = (n - 1) & hash)) == null)，是否发生hash冲突
4.1没有发生hash冲突，基于cas操作，新建一个Node结点，替换原来的null if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null))) break; 替换失败自旋
4.2发生冲突，判断头结点的hash值是不是-1，((fh = f.hash) == MOVED) ，如果是-1 ，tab = helpTransfer(tab, f); 帮助扩容
4.3发生冲突，锁住头结点，synchronized (f)。
4.3.1 table中的第I个元素是头结点，if (tabAt(tab, i) == f)，走链表形式添加元素
4.3.2 table中的第i个元素是树结点类型，f instanceof TreeBin，走树形式的添加元素
4.4发生冲突，并且个数>=8了，将链表改红黑树
treeifyBin(tab, i);
5.addCount(1L, binCount);
helpTransfer
帮助扩容逻辑：
/**
* 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 不是空 且 node 节点是转移类型，数据检验
// 且 node 节点的 nextTable（新 table） 不是空，同样也是数据校验
// 尝试帮助扩容
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
// 根据 length 得到一个标识符号
int rs = resizeStamp(tab.length);
// 如果 nextTab 没有被并发修改 且 tab 也没有被并发修改
// 且 sizeCtl < 0 （说明还在扩容）
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
// 如果 sizeCtl 无符号右移 16 不等于 rs （ sc前 16 位如果不等于标识符，则标识符变化了）
// 或者 sizeCtl == rs + 1 （扩容结束了，不再有线程进行扩容）（默认第一个线程设置 sc ==rs 左移 16 位 + 2，当第一个线程结束扩容了，就会将 sc 减一。这个时候，sc 就等于 rs + 1）
// 或者 sizeCtl == rs + 65535 （如果达到最大帮助线程的数量，即 65535）
// 或者转移下标正在调整 （扩容结束）
// 结束循环，返回 table
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;
}
https://blog.csdn.net/u010285974/article/details/106301938/
addCount逻辑
private final void addCount(long x, int check) {
// s -> size ; b -> baseCount
CounterCell[] cs; long b, s;
// 如果 counterCells 不为空，则表示有多线程使用过了 cell，
// 一旦用过 counterCells 则后续都要用它来计数
// 如果没有用过，说明未遇到过并发，继续使用最 baseCount 增加个数，失败则转入多线程处理方式
if ((cs = counterCells) != null ||
!U.compareAndSetLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell c; long v; int m;
// uncontended : 不受欢迎的、不建议的，这里表示没有竞争（预想没有）
// 标记是因为 CounterCells 为空才进入 fullAddCount 还是因为 CAS 并发替换失败才进入 fullAddCount
// uncontended = true 即表示由无并发进入，否则为 CAS 并发失败进入
boolean uncontended = true;
if (cs == null || (m = cs.length - 1) < 0 ||
(c = cs[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSetLong(c, CELLVALUE, v = c.value, v + x))) {
// 只有此方法为 counterCells 赋值
// 只有 CAS 替换失败时，uncontended 才为 false，否则都为 true
// CAS 替换这里，因为 ThreadLocalRandom#getProbe 的原因，还存在以下情况
// 1. Thread 的 Probe 默认情况下是不会初始化的，所以只有初值 0 ，只有通过 ThreadLocalRandom#current 才会强制初始化
// 也就是说，多线程情况下，如果线程都没有初始化过 Probe，此时如果 CAS 都替换成功，则值都增加到同一个 CounterCell[0] 中，
// 这种情况并不影响并发考虑，因为 CAS 替换的最终也只是一个值，而不是一个队列或数组，不会过分增加负担
// 另外两种情况在方法内被处理
fullAddCount(x, uncontended);
// 并发导致执行 fullAddCount 后，直接退出，不再考虑扩容检查
return;
}
// 仅在无竞争条件下进行检查（只有一个则不需要进行检查）
// 影响数 <= 1，减少扩容的并发检查
if (check <= 1)
return;
// 而此操作则是在无并发的情况下的处理（外部 CAS(CounterCells[n]) 成功）
s = sumCount();
}
if (check >= 0) {
// nt -> nextTable
// n -> num，sc -> sizeCtl
Node<K,V>[] tab, nt; int n, sc;
// 当前存储大于 75%，且总大小小于最大容量
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// resizeStamp 纯粹只是移位来保证右 16 位为0，可用来控制作为线程最大数
// 左 16 位实际并没有保留太多信息（因为明显：resizeStamp(4)、resizeStamp(5)、resizeStamp(6)、(7) 是相同的结果
int rs = resizeStamp(n) << RESIZE_STAMP_SHIFT;
if (sc < 0) {
// 限制线程的最大或最小，当达到最大 65535（默认） 或 1 条时，则直接跳出
// rs + 1 --> 最少线程数（相当于不正确的情况了，因为起始时最少是 rs + 2）
// rs + MAX_RESIZERS --> 最多线程数
// 或其他情况，则不再辅助转移，如：nextable 已为 null 或 transferIndex <= 0（说明已结束）
// 前两个条件是限制线程数，后两个条件是扩容已经结束
if (sc == rs + MAX_RESIZERS || sc == rs + 1 ||
(nt = nextTable) == null || transferIndex <= 0)
break;
if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 如果 sc > 0，说明是刚开始，因为 sc < 0 时，表示有多少条线程在进行转移是：sc-1
// 所以这里要 rs + 2
else if (U.compareAndSetInt(this, SIZECTL, sc, rs + 2))
transfer(tab, null);
s = sumCount();
}
}
fullAddCount
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
// collide ： 碰撞，是否冲突（这属于进入方法 rehash 后的重新一次冲突检测）
boolean collide = false; // True if last slot nonempty
for (;;) {
CounterCell[] cs; CounterCell c; int n; long v;
// 非空，且 size 大于 0，通过线程的 hash & size ，定位所在的 CounterCell
if ((cs = counterCells) != null && (n = cs.length) > 0) {
// 第一步：解决问题 c = cs[ThreadLocalRandom.getProbe() & m]) == null，即初始化或扩容产生的新 CounterCell
if ((c = cs[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to attach new Cell
// 初始化值，赋值完成后就 break 了
CounterCell r = new CounterCell(x); // Optimistic create
// CAS 替换，相当于获取锁，只有一条线程能够进入
if (cellsBusy == 0 &&
U.compareAndSetInt(this, CELLSBUSY, 0, 1)) {
// 创建完毕
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;
}
} finally {
// 释放锁
cellsBusy = 0;
}
if (created)
break;
continue; // Slot is now non-empty
}
}
collide = false;
}
else if (!wasUncontended) // CAS already known to fail
// 此处只有 CAS 失败的才会进入，将为 CAS 尝试做一次 rehash 操作，然后重新尝试
wasUncontended = true; // Continue after rehash
else if (U.compareAndSetLong(c, CELLVALUE, v = c.value, v + x)) // 如果已存在值，则进行 CAS 替换，不成功继续死循环
break;
else if (counterCells != cs || n >= NCPU)
// 边界判断，如果没有正在扩容，则判断是否超过大小边界，是则进行 rehash，否则扩容
// 正处于无效状态或 CounterCell 大小已超过 CPU 个数，此时对 Probe 进行重置（翻倍）
collide = false; // At max size or stale
else if (!collide)
collide = true;
else if (cellsBusy == 0 &&
U.compareAndSetInt(this, CELLSBUSY, 0, 1)) {
try {
// 翻倍
if (counterCells == cs) // Expand table unless stale
counterCells = Arrays.copyOf(cs, n << 1);
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
h = ThreadLocalRandom.advanceProbe(h);
}
// cellsBusy 为 0 且 counterCells == cs 相等（cs 在前面被赋值：cs=counterCells），CAS 替换 cellsBusy 成功，进入初始化
else if (cellsBusy == 0 && counterCells == cs &&
U.compareAndSetInt(this, CELLSBUSY, 0, 1)) {
//...省略
}
else if (U.compareAndSetLong(this, BASECOUNT, v = baseCount, v + x))
// 如果上述两个步骤无法进入，认为出现了错误，使用 CAS(BaseCount) 作为备用/保障选项
break; // Fall back on using base
}
}
并发编程——ConcurrentHashMap#transfer() 扩容逐行分析 - 掘金
扩容逻辑
/**
* Moves and/or copies the nodes in each bin to new table. See
* above for explanation.
*
* transferIndex 表示转移时的下标，初始为扩容前的 length。
*
* 我们假设长度是 32
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// 将 length / 8 然后除以 CPU核心数。如果得到的结果小于 16，那么就使用 16。
// 这里的目的是让每个 CPU 处理的桶一样多，避免出现转移任务不均匀的现象，如果桶较少的话，默认一个 CPU（一个线程）处理 16 个桶
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range 细分范围 stridea：TODO
// 新的 table 尚未初始化
if (nextTab == null) { // initiating
try {
// 扩容 2 倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
// 更新
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
// 扩容失败， sizeCtl 使用 int 最大值。
sizeCtl = Integer.MAX_VALUE;
return;// 结束
}
// 更新成员变量
nextTable = nextTab;
// 更新转移下标，就是 老的 tab 的 length
transferIndex = n;
}
// 新 tab 的 length
int nextn = nextTab.length;
// 创建一个 fwd 节点，用于占位。当别的线程发现这个槽位中是 fwd 类型的节点，则跳过这个节点。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 首次推进为 true，如果等于 true，说明需要再次推进一个下标（i--），反之，如果是 false，那么就不能推进下标，需要将当前的下标处理完毕才能继续推进
boolean advance = true;
// 完成状态，如果是 true，就结束此方法。
boolean finishing = false; // to ensure sweep before committing nextTab
// 死循环,i 表示下标，bound 表示当前线程可以处理的当前桶区间最小下标
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 如果当前线程可以向后推进；这个循环就是控制 i 递减。同时，每个线程都会进入这里取得自己需要转移的桶的区间
while (advance) {
int nextIndex, nextBound;
// 对 i 减一，判断是否大于等于 bound （正常情况下，如果大于 bound 不成立，说明该线程上次领取的任务已经完成了。那么，需要在下面继续领取任务）
// 如果对 i 减一大于等于 bound（还需要继续做任务），或者完成了，修改推进状态为 false，不能推进了。任务成功后修改推进状态为 true。
// 通常，第一次进入循环，i-- 这个判断会无法通过，从而走下面的 nextIndex 赋值操作（获取最新的转移下标）。其余情况都是：如果可以推进，将 i 减一，然后修改成不可推进。如果 i 对应的桶处理成功了，改成可以推进。
if (--i >= bound || finishing)
advance = false;// 这里设置 false，是为了防止在没有成功处理一个桶的情况下却进行了推进
// 这里的目的是：1. 当一个线程进入时，会选取最新的转移下标。2. 当一个线程处理完自己的区间时，如果还有剩余区间的没有别的线程处理。再次获取区间。
else if ((nextIndex = transferIndex) <= 0) {
// 如果小于等于0，说明没有区间了 ，i 改成 -1，推进状态变成 false，不再推进，表示，扩容结束了，当前线程可以退出了
// 这个 -1 会在下面的 if 块里判断，从而进入完成状态判断
i = -1;
advance = false;// 这里设置 false，是为了防止在没有成功处理一个桶的情况下却进行了推进
}// CAS 修改 transferIndex，即 length - 区间值，留下剩余的区间值供后面的线程使用
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;// 这个值就是当前线程可以处理的最小当前区间最小下标
i = nextIndex - 1; // 初次对i 赋值，这个就是当前线程可以处理的当前区间的最大下标
advance = false; // 这里设置 false，是为了防止在没有成功处理一个桶的情况下却进行了推进，这样对导致漏掉某个桶。下面的 if (tabAt(tab, i) == f) 判断会出现这样的情况。
}
}// 如果 i 小于0 （不在 tab 下标内，按照上面的判断，领取最后一段区间的线程扩容结束）
// 如果 i >= tab.length(不知道为什么这么判断)
// 如果 i + tab.length >= nextTable.length （不知道为什么这么判断）
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) { // 如果完成了扩容
nextTable = null;// 删除成员变量
table = nextTab;// 更新 table
sizeCtl = (n << 1) - (n >>> 1); // 更新阈值
return;// 结束方法。
}// 如果没完成
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {// 尝试将 sc -1. 表示这个线程结束帮助扩容了，将 sc 的低 16 位减一。
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)// 如果 sc - 2 不等于标识符左移 16 位。如果他们相等了，说明没有线程在帮助他们扩容了。也就是说，扩容结束了。
return;// 不相等，说明没结束，当前线程结束方法。
finishing = advance = true;// 如果相等，扩容结束了，更新 finising 变量
i = n; // 再次循环检查一下整张表
}
}
else if ((f = tabAt(tab, i)) == null) // 获取老 tab i 下标位置的变量，如果是 null，就使用 fwd 占位。
advance = casTabAt(tab, i, null, fwd);// 如果成功写入 fwd 占位，再次推进一个下标
else if ((fh = f.hash) == MOVED)// 如果不是 null 且 hash 值是 MOVED。
advance = true; // already processed // 说明别的线程已经处理过了，再次推进一个下标
else {// 到这里，说明这个位置有实际值了，且不是占位符。对这个节点上锁。为什么上锁，防止 putVal 的时候向链表插入数据
synchronized (f) {
// 判断 i 下标处的桶节点是否和 f 相同
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;// low, height 高位桶，低位桶
// 如果 f 的 hash 值大于 0 。TreeBin 的 hash 是 -2
if (fh >= 0) {
// 对老长度进行与运算（第一个操作数的的第n位于第二个操作数的第n位如果都是1，那么结果的第n为也为1，否则为0）
// 由于 Map 的长度都是 2 的次方（000001000 这类的数字），那么取于 length 只有 2 种结果，一种是 0，一种是1
// 如果是结果是0 ，Doug Lea 将其放在低位，反之放在高位，目的是将链表重新 hash，放到对应的位置上，让新的取于算法能够击中他。
int runBit = fh & n;
Node<K,V> lastRun = f; // 尾节点，且和头节点的 hash 值取于不相等
// 遍历这个桶
for (Node<K,V> p = f.next; p != null; p = p.next) {
// 取于桶中每个节点的 hash 值
int b = p.hash & n;
// 如果节点的 hash 值和首节点的 hash 值取于结果不同
if (b != runBit) {
runBit = b; // 更新 runBit，用于下面判断 lastRun 该赋值给 ln 还是 hn。
lastRun = p; // 这个 lastRun 保证后面的节点与自己的取于值相同，避免后面没有必要的循环
}
}
if (runBit == 0) {// 如果最后更新的 runBit 是 0 ，设置低位节点
ln = lastRun;
hn = null;
}
else {
hn = lastRun; // 如果最后更新的 runBit 是 1， 设置高位节点
ln = null;
}// 再次循环，生成两个链表，lastRun 作为停止条件，这样就是避免无谓的循环（lastRun 后面都是相同的取于结果）
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
// 如果与运算结果是 0，那么就还在低位
if ((ph & n) == 0) // 如果是0 ，那么创建低位节点
ln = new Node<K,V>(ph, pk, pv, ln);
else // 1 则创建高位
hn = new Node<K,V>(ph, pk, pv, hn);
}
// 其实这里类似 hashMap
// 设置低位链表放在新链表的 i
setTabAt(nextTab, i, ln);
// 设置高位链表，在原有长度上加 n
setTabAt(nextTab, i + n, hn);
// 将旧的链表设置成占位符
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);
// 和链表相同的判断，与运算 == 0 的放在低位
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
} // 不是 0 的放在高位
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
// 如果树的节点数小于等于 6，那么转成链表，反之，创建一个新的树
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;
}
}
}
}
}
}
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
