volatile就是配合cas保證線程安全的。
兩個作用，一個是代表鏈表處理完畢，一個是去新的鏈表找。
鏈表比較長就是從o(1)到o(n)。
用紅黑樹替換下。
8先嚐試擴容，到64以後，變爲紅黑樹，6變回來。
---150---
源碼分析：
三個參數，初始容量，負載因子，辦法度。
實現的是懶惰的初始化，第一次用的時候纔會初始化的。
8的話就是16。
0.75是擴容的閾值。
下次擴容就擴容爲16。
---151---
get方法：
get的全程不加鎖的。
看下tabAt方法：
按照位與就是取模。
node創建好了就有自己的hash了。
---
get的時候必須是key和equals都一樣的。
---
看下：
調用find方法去新的table找key。
---
---
---152---
put流程：
---
true不會覆蓋舊值。
---
不準有空的鍵值。
---
懶惰初始化，創建完成進入下一個循環去put。
---
頭結點是空的我佔位。
---
看下頭節點是不是在進行擴容。是的話我就去幫忙擴容的。
---153---
進入就不是擴容也不是初始化了，並且桶下標被佔位衝突了。只有在這裏加鎖了。
1.看下鏈表的頭節點有沒有被移動過。
2.頭節點的hash碼都是大於0的。紅黑樹或者在擴容是小於0的。
3.普通節點就是下面的邏輯
4.紅黑樹
5.嘗試把鏈表轉化爲紅黑樹
6.這個類似於LongAddr的邏輯.，提高併發度。
---154---
看下這個方法：
我創建其他的線程就不能創建了。
---155---
addCount方法：
第一個參數是1第二個參數是鏈表的長度。類似LongAddr的思想設置累加單元，增加併發度。
1.沒有累加單數組或者是沒有累加單元。
2.是不是需要擴容：https://blog.csdn.net/jupiter_888/article/details/103852735
3.這裏改爲負數進行擴容。
4.擴容。
5.其他的線程，幫忙擴容。
---156---
size流程
SIZE的獲得是不準確的。
---157---
看下擴容的流程：
// 原始的table 新的table
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
// 創建新的
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;
}
int nextn = nextTab.length;
// 處理完替換爲這個
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
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;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
// 鏈表頭處理完了 會替換爲fwd
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 已經是了 處理下一個鏈表
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 鏈表頭有元素的鎖住
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
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;
}
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);
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);
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);
advance = true;
}
}
}
}
}
}
---158---