/* sizeCtl = -1：说明当前ConcurrentHashMap正在初始化！！！
sizeCtl = -N：说明当前ConcurrentHashMap正在扩容！！！
sizeCtl = 0：默认初始值，当前ConcurrentHashMap还没有初始化
sizeCtl > 0：如果已经初始化过了，sizeCtl标识扩容的阈值， 如果没有初始化，sizeCtl标识数组的初始化容量 */
private final Node<K,V>[] initTable() {
// 声明一些变量
Node<K,V>[] tab; int sc;
// tab变量是HashMap的数组， 数组长度为null，或者数组的长度为0，说明数组还没有初始化！
while ((tab = table) == null || tab.length == 0) {
// 将sizeCtl赋值给sc，如果进到if中，说明正在扩容或者正在初始化
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// 以CAS的方式，尝试将sizeCtl从之前oldValue替换为-1，为了标识我当前ConcurrentHashMap正在初始化
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
// 开始扩容
try {
//DCL思想
// table是不是还是null，或者长度还是0
if ((tab = table) == null || tab.length == 0) {
// 声明n，sc是sizeCtl，默认sizectl为0，但是现在正在初始化，我把sizeCtl改为了-1，但是sc还是0 ```
Node<K,V> b; int n, sc;
if (tab != null) {
// MIN_TREEIFY_CAPACITY 为 64
// 所以，如果数组长度小于 64 的时候，其实也就是 32 或者 16 或者更小的时候，会进行数组扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 后面我们再详细分析这个方法
tryPresize(n << 1);
// b 是头节点
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 加锁
synchronized (b) {
if (tabAt(tab, index) == b) {
// 下面就是遍历链表，建立一颗红黑树
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p =
// sc如果为0，不大于0，所以为DEFAULT_CAPACITY，16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 创建数组！！！
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
// 将初始化的nt数组赋值给ConcurrentHashMap的table
table = tab = nt;
// 默认sc = 12，为扩容阈值```
Node<K,V> b; int n, sc;
if (tab != null) {
// MIN_TREEIFY_CAPACITY 为 64
// 所以，如果数组长度小于 64 的时候，其实也就是 32 或者 16 或者更小的时候，会进行数组扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 后面我们再详细分析这个方法
tryPresize(n << 1);
// b 是头节点
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 加锁
synchronized (b) {
if (tabAt(tab, index) == b) {
// 下面就是遍历链表，建立一颗红黑树
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p =
sc = n - (n >>> 2);
}
} finally {
// 将阈值赋值给sizeCtl，到这初始化完毕
sizeCtl = sc;
}
break;
}
}
return tab;
Node<K,V> b; int n, sc;
if (tab != null) {
// MIN_TREEIFY_CAPACITY 为 64
// 所以，如果数组长度小于 64 的时候，其实也就是 32 或者 16 或者更小的时候，会进行数组扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 后面我们再详细分析这个方法
tryPresize(n << 1);
// b 是头节点
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 加锁
synchronized (b) {
if (tabAt(tab, index) == b) {
// 下面就是遍历链表，建立一颗红黑树
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
https://www.laipuhuo.com/goodsDetail/01EC88F9739A464B9CBAC6F5B3F1A8CC.html
https://www.laipuhuo.com/goodsDetail/01ed3b6143214668897d8af195325e77.html
https://www.laipuhuo.com/goodsDetail/01f2a21598e9457a8d966206df135bc2.htm
https://www.laipuhuo.com/goodsDetail/01f35571a1b644fca099b8a763fae3e1.html
https://www.laipuhuo.com/goodsDetail/01f8c6d04632430daf9771f855ab42e9.html
https://www.laipuhuo.com/goodsDetail/01FAA7E8E45C4F4B88D552DF96A78567.html
https://www.laipuhuo.com/goodsDetail/01fb9363baf34012b0a88261dc04719b.html
Node<K,V> b; int n, sc;
if (tab != null) {
// MIN_TREEIFY_CAPACITY 为 64
// 所以，如果数组长度小于 64 的时候，其实也就是 32 或者 16 或者更小的时候，会进行数组扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
// 后面我们再详细分析这个方法
tryPresize(n << 1);
// b 是头节点
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
// 加锁
synchronized (b) {
if (tabAt(tab, index) == b) {
// 下面就是遍历链表，建立一颗红黑树
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p =
```
