Java多線程進階（二四）—— J.U.C之collections框架：ConcurrentHashMap(2) 擴容
本文首發於一世流雲專欄： https://segmentfault.com/blog...
經過上一篇文章——ConcurrentHashMap原理(1)，相信讀者對ConcurrentHashMap的基本原理有了一個初步認識，可是上一篇中還有一個遺留問題沒有討論到，那就是ConcurrentHashMap的擴容和數據遷移。本文中，咱們將會對這兩個問題進行討論。java
1、擴容的基本思路
JDK1.8中，ConcurrentHashMap最複雜的部分就是擴容/數據遷移，涉及多線程的合做和rehash。咱們先來考慮下通常狀況下，如何對一個Hash表進行擴容。segmentfault
擴容思路
Hash表的擴容，通常都包含兩個步驟：數組
①table數組的擴容
table數組的擴容，通常就是新建一個2倍大小的槽數組，這個過程經過由一個單線程完成，且不容許出現併發。多線程
②數據遷移
所謂數據遷移，就是把舊table中的各個槽中的結點從新分配到新table中。好比，單線程狀況下，能夠遍歷原來的table，而後put到新table中。併發
這一過程一般涉及到槽中key的rehash，由於key映射到桶的位置與table的大小有關，新table的大小變了，key映射的位置通常也會變化。ide
ConcurrentHashMap在處理rehash的時候，並不會從新計算每一個key的hash值，而是利用了一種很巧妙的方法。咱們在上一篇說過，ConcurrentHashMap內部的table數組的大小必須爲2的冪次，緣由是讓key均勻分佈，減小衝突，這只是其中一個緣由。另外一個緣由就是：this
當table數組的大小爲2的冪次時，經過key.hash & table.length-1這種方式計算出的索引i，當table擴容後（2倍），新的索引要麼在原來的位置i，要麼是i+n。
咱們來看個例子：
spa
上圖中：
擴容前，table數組大小爲16，key1和key2映射到同一個索引5；
擴容後，table數組的大小變成 2*16=32 ，key1的索引不變，key2的索引變成 5+16=21。線程
並且還有一個特色，擴容後key對應的索引若是發生了變化，那麼其變化後的索引最高位必定是1（見擴容後key2的最高位）。code
這種處理方式很是利於擴容時多個線程同時進行的數據遷移操做，由於舊table的各個桶中的結點遷移不會互相影響，因此就能夠用 「分治」的方式，將整個table數組劃分爲不少部分，每一部分包含必定區間的桶，每一個數據遷移線程處理各自區間中的結點，對多線程同時進行數據遷移很是有利，後面咱們會詳細介紹。
擴容時機
咱們再來看下，ConcurrentHashMap什麼時候會發生擴容。
在上篇文章中，咱們提到過，當往Map中插入結點時，若是鏈表的結點數目超過必定閾值，就會觸發鏈表 -> 紅黑樹的轉換：
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i); // 鏈表 -> 紅黑樹 轉換
如今，咱們來分析下treeifyBin這個紅黑樹化的操做：
/**
* 嘗試進行 鏈表 -> 紅黑樹 的轉換.
*/
private final void treeifyBin(Node<K, V>[] tab, int index) {
Node<K, V> b;
int n, sc;
if (tab != null) {
// CASE 1: table的容量 < MIN_TREEIFY_CAPACITY(64)時，直接進行table擴容，不進行紅黑樹轉換
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);
// CASE 2: table的容量 ≥ MIN_TREEIFY_CAPACITY(64)時，進行鏈表 -> 紅黑樹的轉換
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 = new TreeNode<K, V>(e.hash, e.key, e.val, null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
// 以TreeBin類型包裝，並連接到table[index]中
setTabAt(tab, index, new TreeBin<K, V>(hd));
}
}
}
}
}
上述第一個分支中，還會再對table數組的長度進行一次判斷：
若是table長度小於閾值MIN_TREEIFY_CAPACITY——默認64，則會調用tryPresize方法把數組長度擴大到原來的兩倍。
從代碼也能夠看到，鏈表 -> 紅黑樹這一轉換並非必定會進行的，table長度較小時，CurrentHashMap會首先選擇擴容，而非當即轉換成紅黑樹。
來看下tryPresize方法如何執行擴容：
/**
* 嘗試對table數組進行擴容.
*
* @param 待擴容的大小
*/
private final void tryPresize(int size) {
// 視狀況將size調整爲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;
//CASE 1: table還未初始化，則先進行初始化
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
// CASE2: c <= sc說明已經被擴容過了；n >= MAXIMUM_CAPACITY說明table數組已達到最大容量
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
// CASE3: 進行table擴容
else if (tab == table) {
int rs = resizeStamp(n); // 根據容量n生成一個隨機數，惟一標識本次擴容操做
if (sc < 0) { // 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;
// 協助數據轉移, 把正在執行transfer任務的線程數加1
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// sc置爲負數, 當前線程自身成爲第一個執行transfer(數據轉移)的線程
// 這個CAS操做能夠保證，僅有一個線程會執行擴容
else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
前兩個分支沒什麼好說的，看下注釋很容易理解，關鍵看第三個分支 —— CASE3：進行table擴容。CASE3其實分爲兩種狀況：
- 已經有其它線程正在執行擴容了，則當前線程會嘗試協助「數據遷移」；（多線程併發）
- 沒有其它線程正在執行擴容，則當前線程自身發起擴容。（單線程）
注意：這兩種狀況都是調用了transfer方法，經過第二個入參nextTab進行區分（nextTab表示擴容後的新table數組，若是爲null，表示首次發起擴容）。
第二種狀況下，是經過CAS和移位運算來保證僅有一個線程能發起擴容。
2、擴容的原理
咱們來看下transfer方法，這個方法能夠被多個線程同時調用，也是「數據遷移」的核心操做方法：
/**
* 數據轉移和擴容.
* 每一個調用tranfer的線程會對當前舊table中[transferIndex-stride, transferIndex-1]位置的結點進行遷移
*
* @param tab 舊table數組
* @param nextTab 新table數組
*/
private final void transfer(Node<K, V>[] tab, Node<K, V>[] nextTab) {
int n = tab.length, stride;
// stride可理解成「步長」，即數據遷移時，每一個線程要負責舊table中的多少個桶
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
if (nextTab == null) { // 首次擴容
try {
// 建立新table數組
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // 處理內存溢出（OOME）的狀況
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n; // [transferIndex-stride, transferIndex-1]表示當前線程要進行數據遷移的桶區間
}
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;
} 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) { // CASE1：當前是處理最後一個tranfer任務的線程或出現擴容衝突
int sc;
if (finishing) { // 全部桶遷移均已完成
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 擴容線程數減1,表示當前線程已完成本身的transfer任務
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 判斷當前線程是不是本輪擴容中的最後一個線程，若是不是，則直接退出
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
/**
* 最後一個數據遷移線程要從新檢查一次舊table中的全部桶，看是否都被正確遷移到新table了：
* ①正常狀況下，從新檢查時，舊table的全部桶都應該是ForwardingNode;
* ②特殊狀況下，好比擴容衝突(多個線程申請到了同一個transfer任務)，此時當前線程領取的任務會做廢，那麼最後檢查時，
* 還要處理由於做廢而沒有被遷移的桶，把它們正確遷移到新table中
*/
i = n; // recheck before commit
}
} else if ((f = tabAt(tab, i)) == null) // CASE2：舊桶自己爲null，不用遷移，直接嘗試放一個ForwardingNode
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED) // CASE3：該舊桶已經遷移完成，直接跳過
advance = true;
else { // CASE4：該舊桶未遷移完成，進行數據遷移
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K, V> ln, hn;
if (fh >= 0) { // CASE4.1：桶的hash>0，說明是鏈表遷移
/**
* 下面的過程會將舊桶中的鏈表分紅兩部分：ln鏈和hn鏈
* ln鏈會插入到新table的槽i中，hn鏈會插入到新table的槽i+n中
*/
int runBit = fh & n; // 因爲n是2的冪次，因此runBit要麼是0，要麼高位是1
Node<K, V> lastRun = f; // lastRun指向最後一個相鄰runBit不一樣的結點
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所指向的結點爲分界，將鏈表拆成2個子鏈表ln、hn
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); // ln鏈表存入新桶的索引i位置
setTabAt(nextTab, i + n, hn); // hn鏈表存入新桶的索引i+n位置
setTabAt(tab, i, fwd); // 設置ForwardingNode佔位
advance = true; // 表示當前舊桶的結點已遷移完畢
}
else if (f instanceof TreeBin) { // CASE4.2：紅黑樹遷移
/**
* 下面的過程會先以鏈表方式遍歷，複製全部結點，而後根據高低位組裝成兩個鏈表；
* 而後看下是否須要進行紅黑樹轉換，最後放到新table對應的桶中
*/
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); // 設置ForwardingNode佔位
advance = true; // 表示當前舊桶的結點已遷移完畢
}
}
}
}
}
}
tranfer方法的開頭，會計算出一個stride變量的值，這個stride其實就是每一個線程處理的桶區間，也就是步長：
// stride可理解成「步長」，即數據遷移時，每一個線程要負責舊table中的多少個桶
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
首次擴容時，會將table數組變成原來的2倍：
if (nextTab == null) { // 首次擴容
try {
// 建立新table數組
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n << 1];
nextTab = nt;
} catch (Throwable ex) { // 處理內存溢出（OOME）的狀況
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n; // [transferIndex-stride, transferIndex-1]表示當前線程要進行數據遷移的桶區間
}
注意上面的transferIndex變量，這是一個字段，table[transferIndex-stride, transferIndex-1]就是當前線程要進行數據遷移的桶區間：
/** * 擴容時須要用到的一個下標變量. */ private transient volatile int transferIndex;
整個transfer方法幾乎都在一個自旋操做中完成，從右往左開始進行數據遷移，transfer的退出點是當某個線程處理完最後的table區段——table[0,stride-1]。
transfer方法主要包含4個分支，即對4種不一樣狀況進行處理，咱們按照難易程度來解釋下各個分支所作的事情：
CASE2：桶table[i]爲空
當舊table的桶table[i] == null，說明原來這個桶就沒有數據，那就直接嘗試放置一個ForwardingNode，表示這個桶已經處理完成。
else if ((f = tabAt(tab, i)) == null) // CASE2：舊桶自己爲null，不用遷移，直接嘗試放一個ForwardingNode
advance = casTabAt(tab, i, null, fwd);
注： ForwardingNode咱們在上一篇提到過，主要作佔用位，多線程進行數據遷移時，其它線程看到這個桶中是ForwardingNode結點，就知道有線程已經在數據遷移了。
另外，當最後一個線程完成遷移任務後，會遍歷全部桶，看看是否都是ForwardingNode，若是是，那麼說明整個擴容/數據遷移的過程就完成了。
CASE3：桶table[i]已遷移完成
沒什麼好說的，就是桶已經用ForwardingNode結點佔用了，表示該桶的數據都遷移完了。
else if ((fh = f.hash) == MOVED) // CASE3：該舊桶已經遷移完成，直接跳過
advance = true;
CASE4：桶table[i]未遷移完成
若是舊桶的數據未遷移完成，就要進行遷移，這裏根據桶中結點的類型分爲：鏈表遷移、紅黑樹遷移。
①鏈表遷移
鏈表遷移的過程以下，首先會遍歷一遍原鏈表，找到最後一個相鄰runBit不一樣的結點。runbit是根據key.hash和舊table長度n進行與運算獲得的值，因爲table的長度爲2的冪次，因此runbit只可能爲0或最高位爲1
而後，會進行第二次鏈表遍歷，按照第一次遍歷找到的結點爲界，將原鏈表分紅2個子鏈表，再連接到新table的槽中。能夠看到，新table的索引要麼是i，要麼是i+n，這裏就利用了上一節說的ConcurrentHashMap的rehash特色。
if (fh >= 0) { // CASE4.1：桶的hash>0，說明是鏈表遷移
/**
* 下面的過程會將舊桶中的鏈表分紅兩部分：ln鏈和hn鏈
* ln鏈會插入到新table的槽i中，hn鏈會插入到新table的槽i+n中
*/
int runBit = fh & n; // 因爲n是2的冪次，因此runBit要麼是0，要麼高位是1
Node<K, V> lastRun = f; // lastRun指向最後一個相鄰runBit不一樣的結點
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所指向的結點爲分界，將鏈表拆成2個子鏈表ln、hn
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); // ln鏈表存入新桶的索引i位置
setTabAt(nextTab, i + n, hn); // hn鏈表存入新桶的索引i+n位置
setTabAt(tab, i, fwd); // 設置ForwardingNode佔位
advance = true; // 表示當前舊桶的結點已遷移完畢
}
②紅黑樹遷移
紅黑樹的遷移按照鏈表遍歷的方式進行，當鏈表結點超過/小於閾值時，涉及紅黑樹<->鏈表的相互轉換：
else if (f instanceof TreeBin) { // CASE4.2：紅黑樹遷移
/**
* 下面的過程會先以鏈表方式遍歷，複製全部結點，而後根據高低位組裝成兩個鏈表；
* 而後看下是否須要進行紅黑樹轉換，最後放到新table對應的桶中
*/
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); // 設置ForwardingNode佔位
advance = true; // 表示當前舊桶的結點已遷移完畢
}
CASE1：當前是最後一個遷移任務或出現擴容衝突
咱們剛纔說了，調用transfer的線程會自動領用某個區段的桶，進行數據遷移操做，當區段的初始索引i變成負數的時候，說明當前線程處理的其實就是最後剩下的桶，而且處理完了。
因此首先會更新sizeCtl變量，將擴容線程數減1，而後會作一些收尾工做：
設置table指向擴容後的新數組，遍歷一遍舊數組，確保每一個桶的數據都遷移完成——被ForwardingNode佔用。
另外，可能在擴容過程當中，出現擴容衝突的狀況，好比多個線程領用了同一區段的桶，這時任何一個線程都不能進行數據遷移。
if (i < 0 || i >= n || i + n >= nextn) { // CASE1：當前是處理最後一個tranfer任務的線程或出現擴容衝突
int sc;
if (finishing) { // 全部桶遷移均已完成
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 擴容線程數減1,表示當前線程已完成本身的transfer任務
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 判斷當前線程是不是本輪擴容中的最後一個線程，若是不是，則直接退出
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
/**
* 最後一個數據遷移線程要從新檢查一次舊table中的全部桶，看是否都被正確遷移到新table了：
* ①正常狀況下，從新檢查時，舊table的全部桶都應該是ForwardingNode;
* ②特殊狀況下，好比擴容衝突(多個線程申請到了同一個transfer任務)，此時當前線程領取的任務會做廢，那麼最後檢查時，
* 還要處理由於做廢而沒有被遷移的桶，把它們正確遷移到新table中
*/
i = n; // recheck before commit
}
}
相關文章
- 1. Java多線程進階（三四）—— J.U.C之collections框架：PriorityBlockingQueue
- 2. Java多線程進階（三二）—— J.U.C之collections框架：ArrayBlockingQueue
- 3. Java多線程進階（二八）—— J.U.C之collections框架：CopyOnWriteArraySet
- 4. Java多線程進階（二五）—— J.U.C之collections框架：ConcurrentSkipListMap
- 5. Java多線程進階（二九）—— J.U.C之collections框架：ConcurrentLinkedQueue
- 6. Java多線程進階（二七）—— J.U.C之collections框架：CopyOnWriteArrayList
- 7. Java多線程進階（二六）—— J.U.C之collections框架：ConcurrentSkipListSet
- 8. Java多線程進階（三三）—— J.U.C之collections框架：LinkedBlockingQueue
- 9. Java多線程進階（三七）—— J.U.C之collections框架：LinkedBlockingDeque
- 10. Java多線程進階（三一）—— J.U.C之collections框架：BlockingQueue接口
- 更多相關文章...
- • C# 多線程 - C#教程
- • Java Spring框架是什麼？它有哪些好處？ - Spring教程
- • Java 8 Stream 教程
- • RxJava操作符（四）Combining
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java多線程進階（三四）—— J.U.C之collections框架：PriorityBlockingQueue
- 2. Java多線程進階（三二）—— J.U.C之collections框架：ArrayBlockingQueue
- 3. Java多線程進階（二八）—— J.U.C之collections框架：CopyOnWriteArraySet
- 4. Java多線程進階（二五）—— J.U.C之collections框架：ConcurrentSkipListMap
- 5. Java多線程進階（二九）—— J.U.C之collections框架：ConcurrentLinkedQueue
- 6. Java多線程進階（二七）—— J.U.C之collections框架：CopyOnWriteArrayList
- 7. Java多線程進階（二六）—— J.U.C之collections框架：ConcurrentSkipListSet
- 8. Java多線程進階（三三）—— J.U.C之collections框架：LinkedBlockingQueue
- 9. Java多線程進階（三七）—— J.U.C之collections框架：LinkedBlockingDeque
- 10. Java多線程進階（三一）—— J.U.C之collections框架：BlockingQueue接口