前言
ConcurrentHashMap 是並發中的重中之重，也是最常用的數據結果，之前的文章中，我們介紹了 putVal 方法。並發編程之 ConcurrentHashMap（JDK 1.8） putVal 源碼分析。其中分析了 initTable 方法和 putVal 方法，但也留下了一句話：
這篇文章僅僅是 ConcurrentHashMap 的開頭，關於 ConcurrentHashMap 里面的精華太多，值得我們好好學習。
說道精華，他的擴容方法絕對是精華，要知道，ConcurrentHashMap 擴容是高度並發的。
今天來逐行分析源碼。
先說結論
首先說結論。源碼加注釋我會放在后面。該方法的執行邏輯如下：
-
通過計算 CPU 核心數和 Map 數組的長度得到每個線程（CPU）要幫助處理多少個桶，並且這里每個線程處理都是平均的。默認每個線程處理 16 個桶。因此，如果長度是 16 的時候，擴容的時候只會有一個線程擴容。
-
初始化臨時變量 nextTable。將其在原有基礎上擴容兩倍。
-
死循環開始轉移。多線程並發轉移就是在這個死循環中，根據一個 finishing 變量來判斷，該變量為 true 表示擴容結束，否則繼續擴容。
3.1 進入一個 while 循環，分配數組中一個桶的區間給線程，默認是 16. 從大到小進行分配。當拿到分配值后，進行 i-- 遞減。這個 i 就是數組下標。（
其中有一個 bound 參數，這個參數指的是該線程此次可以處理的區間的最小下標，超過這個下標，就需要重新領取區間或者結束擴容，還有一個 advance 參數，該參數指的是是否繼續遞減轉移下一個桶，如果為 true，表示可以繼續向后推進，反之，說明還沒有處理好當前桶，不能推進)
3.2 出 while 循環，進 if 判斷，判斷擴容是否結束，如果擴容結束，清空臨死變量，更新 table 變量，更新庫容閾值。如果沒完成，但已經無法領取區間（沒了），該線程退出該方法，並將 sizeCtl 減一，表示擴容的線程少一個了。如果減完這個數以后，sizeCtl 回歸了初始狀態，表示沒有線程再擴容了，該方法所有的線程擴容結束了。（這里主要是判斷擴容任務是否結束，如果結束了就讓線程退出該方法，並更新相關變量）。然后檢查所有的桶，防止遺漏。
3.3 如果沒有完成任務，且 i 對應的槽位是空，嘗試 CAS 插入占位符，讓 putVal 方法的線程感知。
3.4 如果 i 對應的槽位不是空，且有了占位符，那么該線程跳過這個槽位，處理下一個槽位。
3.5 如果以上都是不是，說明這個槽位有一個實際的值。開始同步處理這個桶。
3.6 到這里，都還沒有對桶內數據進行轉移，只是計算了下標和處理區間，然后一些完成狀態判斷。同時，如果對應下標內沒有數據或已經被占位了，就跳過了。 -
處理每個桶的行為都是同步的。防止 putVal 的時候向鏈表插入數據。
4.1 如果這個桶是鏈表，那么就將這個鏈表根據 length 取於拆成兩份，取於結果是 0 的放在新表的低位，取於結果是 1 放在新表的高位。
4.2 如果這個桶是紅黑數，那么也拆成 2 份，方式和鏈表的方式一樣，然后，判斷拆分過的樹的節點數量，如果數量小於等於 6，改造成鏈表。反之，繼續使用紅黑樹結構。
4.3 到這里，就完成了一個桶從舊表轉移到新表的過程。
好，以上，就是 transfer 方法的總體邏輯。還是挺復雜的。再進行精簡，分成 3 步驟：
- 計算每個線程可以處理的桶區間。默認 16.
- 初始化臨時變量 nextTable，擴容 2 倍。
- 死循環，計算下標。完成總體判斷。
- 1 如果桶內有數據，同步轉移數據。通常會像鏈表拆成 2 份。
大體就是上的的 3 個步驟。
再來看看源碼和注釋。
再看源碼分析
源碼加注釋：
/**
* 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;
}
}
}
}
}
}
代碼加注釋比較長，有興趣可以逐行對照，有 2 個判斷樓主看不懂為什么這么判斷，知道的同學可以提醒一下。
然后，說說精華的部分。
- Cmap 支持並發擴容，實現方式是，將表拆分，讓每個線程處理自己的區間。如下圖：
假設總長度是 64 ，每個線程可以分到 16 個桶，各自處理，不會互相影響。
- 而每個線程在處理自己桶中的數據的時候，是下圖這樣的：
擴容前的狀態。
當對 4 號桶或者 10 號桶進行轉移的時候，會將鏈表拆成兩份，規則是根據節點的 hash 值取於 length，如果結果是 0，放在低位，否則放在高位。
因此，10 號桶的數據，黑色節點會放在新表的 10 號位置，白色節點會放在新桶的 26 號位置。
下圖是循環處理桶中數據的邏輯：
處理完之后，新桶的數據是這樣的：
總結
transfer 方法可以說很牛逼，很精華，內部多線程擴容性能很高，
通過給每個線程分配桶區間，避免線程間的爭用，通過為每個桶節點加鎖，避免 putVal 方法導致數據不一致。同時，在擴容的時候，也會將鏈表拆成兩份，這點和 HashMap 的 resize 方法類似。
而如果有新的線程想 put 數據時，也會幫助其擴容。鬼斧神工，令人贊嘆。