一、簡介
在ConcurrentHashMap中，比較複雜部分就是其擴容機制，因爲涉及到多個線程分工合作完成數據遷移和key的rehash操作。
二、擴容思路
ConcurrentHashMap擴容一般分爲兩個步驟：
- 【a】Node<K,V>[] table數組的擴容，一般是擴大到原來數組大小的兩倍；
- 【b】key的rehash以及數據的遷移：因爲計算key在桶中的索引index跟數組的大小有關，現在數組大小擴大了，那麼相應的數組索引也可能發生變化，這就是rehash。所謂數據遷移，就是將原來table數組的各個槽中的節點重新分配到新創建的nextTable中。
注意，ConcurrentHashMap在rehash的時候，並不會重新計算每個key的hash值，而是利用了一種很巧妙的方式。我們都知道ConcurrentHashMap內部的table數組的大小必須爲2的冪次，原因是讓key均勻分佈，減少hash衝突。
還有就是，當table數組的大小爲2的冪次時，我們通過下面的方式計算出來的索引index：
key.hash & table.length-1
這樣在table擴容到兩倍大小時，新的索引要麼在原來的位置i，要麼是i+n。
舉個例子：
假設擴容前table數組大小爲16，有兩個key：
length-1=15： 0000 0000 0000 0000 0000 0000 0000 1111
key1("A")的hash：0000 0000 0000 0000 0000 0000 0100 0001
key2("B")的hash：0000 0000 0000 0000 0000 0000 0100 0010
=======================================================================
&運算後key1： 0000 0000 0000 0000 0000 0000 0000 0001 = 索引爲1
&運算後key2： 0000 0000 0000 0000 0000 0000 0000 0010 = 索引爲2
擴容後，table變爲長度32，同樣是上面兩個key：
length-1=31： 0000 0000 0000 0000 0000 0000 0001 1111
key1("A")的hash：0000 0000 0000 0000 0000 0000 0100 0001
key2("B")的hash：0000 0000 0000 0000 0000 0000 0100 0010
=======================================================================
&運算後key1： 0000 0000 0000 0000 0000 0000 0000 0001 = 索引還爲1
&運算後key2： 0000 0000 0000 0000 0000 0000 0000 0010 = 索引還爲2
由此驗證了上面的：table擴容到兩倍大小時，新的索引要麼在原來的位置i，要麼是i+n.
這種處理方式對於擴容時多個線程同時進行數據遷移操作非常有利，因爲舊table的各個桶中的結點遷移不會互相影響，可以採用“分工合作”的方式，將整個table數組劃分爲很多區間部分，每一部分包含一定區間的桶，每個數據遷移線程處理各自區間中的結點。
三、擴容源碼閱讀
接下來，我們看看ConcurrentHashMap是什麼情況下會發生擴容。通過上一節文章，我們知道了：
當鏈表中的節點數量超過一定的閾值(通常爲8)時，會發生鏈表轉換爲紅黑樹結構。
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
其中轉換方法就是：treeifyBin(tab, i)：
/**
* 鏈表轉換爲紅黑樹的主要方法.
*/
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
//這裏可以看到，鏈表轉換爲紅黑樹結構不單單只是鏈表節點數量超出閾值8
//第二重判斷：table的容量是否小於64，如果小於64, 直接進行table擴容，不會發生紅黑樹轉換
//因此鏈表->紅黑樹 ，不一定鏈表節點數量超過閾值就發生。
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
//table數組擴容重要方法
tryPresize(n << 1);
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) { //table的容量大於等於64時，鏈表將轉換爲紅黑樹
//鎖住table[index]鏈表頭節點
synchronized (b) {
//再次判斷，防止table[i]被其他線程修改
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null;
//循環遍歷鏈表，將每個Node節點轉換爲TreeNode樹節點
for (Node<K,V> e = b; e != null; e = e.next) {
//構建TreeNode樹節點
TreeNode<K,V> p =
new TreeNode<K,V>(e.hash, e.key, e.val,
null, null);
if ((p.prev = tl) == null)
//p作爲頭節點
hd = p;
else
//鏈接上一次遍歷的節點
tl.next = p;
tl = p;
}
//將樹節點鏈接到TreeBin節點
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
從上面的代碼可以看到，如果table長度小於64時，不會發生鏈表轉換爲紅黑樹，而是會調用tryPresize方法把數組長度擴大到原來的兩倍。
下面我們看看tryPresize()：
/**
* 嘗試調整table的大小以適應給定的元素數量
* 擴容重要方法
*/
private final void tryPresize(int size) {
//如果嘗試擴容的容量超過最大容量，那麼無法擴容，直接取MAXIMUM_CAPACITY
//如果沒有超過最大容量，嘗試調整爲： 大於當前容量的2次冪大小
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
//自旋一直判斷
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
//table爲空的話，說明尚未初始化，所以先進行初始化
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
//創建一個長度爲n的Node<K,V>[]賦值給table
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
//如果已經被擴容過或者table數組已經超過最大容量，則直接退出循環
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) { //進行擴容操作
//返回一個隨機數，標誌此次
int rs = resizeStamp(n);
if (sc < 0) { //表明此時有別的線程正在進行擴容
Node<K,V>[] nt;
// 如果當前線程無法協助進行數據轉移, 則退出
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
//協助數據轉移
transfer(tab, nt);
}
// sc置爲負數, 當前線程成爲第一個執行數據轉移的線程
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
可以看到，協助數據遷移和自身成爲第一個進行數據遷移的線程，都是調用的transfer方法來完成：
/**
* 將每個bin中的節點移動或複製到新表中.
* 數據遷移的重要方法
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// stride表示數據遷移時，每個線程要負責舊table中的多少個桶的數據遷移
// 通過cpu的數量
// 假設： n = table.length = 100,cpu的數量=4, 計算得出的stride = 3 < MIN_TRANSFER_STRIDE=16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
//說明最小區間大小就是16
stride = MIN_TRANSFER_STRIDE; // 細分範圍
if (nextTab == null) { // 第一次進行擴容
try {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
//此處就是通過左移一位，創建一個大小爲原先數組大小兩倍的數組
//並且賦值給新數組nextTab
nextTab = nt;
} catch (Throwable ex) { //處理內存溢出（OOME）的情況
sizeCtl = Integer.MAX_VALUE;
return;
}
//賦值給擴容後新數組nextTab
nextTable = nextTab;
// [transferIndex-stride, transferIndex-1]表示當前線程要進行數據遷移的桶區間
// [100-16, 100-1] -> [84,99]
transferIndex = n;
}
int nextn = nextTab.length;
// ForwardingNode結點，當舊table的某個桶中的所有節點都遷移完後，用該節點佔據這個桶
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 標識一個桶的遷移工作是否完成，advance爲true 表示可進行下一個位置的遷移.
boolean advance = true;
// 最後一個線程完成數據遷移後，會將該值置爲true
boolean finishing = false;
// i指當前處理的槽位序號,bound指需要處理的槽位邊界
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 計算本次處理的桶區間
// i == transferIndex-1，bound == transferIndex-stride
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//cas無鎖算法設置 transferIndex = transferIndex - stride
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
nextTable = null;
table = nextTab;
//擴容閾值設置爲原來容量的1.5倍 依然相當於現在容量的0.75倍
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 利用CAS方法更新這個擴容閾值,擴容線程數減1
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 判斷當前線程是否是本次擴容中的最後一個線程，如果不是，則直接退出
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
/**
* 最後一個線程要重新檢查一次舊table中的所有桶，確認是否都被正確遷移到新table
*/
i = n; // recheck before commit
}
}
else if ((f = tabAt(tab, i)) == null)
//對應舊桶中的數據爲null,不需要進行遷移，存放ForwardingNode用於佔位
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) { //桶的hash>0，說明是鏈表遷移
int runBit = fh & n;
Node<K,V> lastRun = f;
//lastRun表示最後一個使fh & n發生變化的節點
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;
}
//可見循環到lastRun爲止， 以lastRun所指向的節點爲分界
for (Node<K,V> p = f; p != lastRun; p = p.next) {
//將鏈表拆成2個子鏈表ln、hn
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);
}
//p.hash & n等於0的節點構成一個鏈表ln,這些節點在新數組中的位置不變
setTabAt(nextTab, i, ln);
//p.hash & n等於1的節點構成一個鏈表hn,這些節點在新數組中的位置爲i+n
setTabAt(nextTab, i + n, hn);
//放置ForwardingNode用於佔位
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;
}
}
}
}
}
}
擴容的大體流程：
- 新數組的長度是原來的2倍；
- 根據不同位置的元素的結構有不同的方式；
- 不管原來是鏈表結構還是樹型結構，擴容以後都變成兩部分，一部分是hash&n爲0的，另一部分是hash&n不爲0的，其中n爲原數組的長度；
- 對於那些hash&n==0的結點，它們在新數組中的位置保持不變，也就是說它們原先在舊數組中是什麼位置，現在在新數組中還是什麼位置；
- 對於那些hash&n != 0的節點，它們在新數組中的位置相比於之前在舊數組中的位置是向後移動了n；
- 每個位置在遷移的時候都加鎖了；
- 擴容後，原來在舊數組中在相同位置的結點在新數組中未必還在相同的位置；
- 擴容後，鏈表沒有倒置；
- 由於遷移到新數組中時，會將原先一棵樹分成兩部分（跟鏈表一樣），所以分出來的樹中如果結點數小於或等於6，則轉成鏈表；
三、總結
通過兩篇ConcurrentHashMap相關的文章，可以對ConcurrentHashMap做一個大概的理解，但是僅僅這些還是不夠的，畢竟ConcurrentHashMap的源碼相對比較複雜，其中涉及紅黑樹那一塊也是很複雜，後面有時間回去閱讀的時候，會繼續完善ConcurrentHashMap相關的知識。以上僅是筆者的學習上的一些總結，如有不對之處，還請大家幫忙指正。
參考資料：
https://www.cnblogs.com/cjsblog/p/10017911.html
https://blog.csdn.net/programmer_at/article/details/79715177