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. 跳槽面试的几个实用小技巧，不妨看看！
- 2. Mac实用技巧 |如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 3. Mac实用技巧 |如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 4. 如何使用Mac系统中自带的预览工具将图片变成黑白色?
- 5. Mac OS非兼容Windows软件运行解决方案——“以VMware & Microsoft Access为例“
- 6. 封装 pyinstaller -F -i b.ico excel.py
- 7. 数据库作业三ER图待完善
- 8. nvm安装使用低版本node.js(非命令安装)
- 9. 如何快速转换图片格式
- 10. 将表格内容分条转换为若干文档
欢迎关注本站公众号,获取更多信息
相关文章
- 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接口