文章目录
ConcurrentHashMap概述
这个Map是由著名java并发大师Doug Lea开发的。位于juc包中。这个类的出现是为了解决HashMap在多线程下并发不安全的问题。这个类比起Hashtable实现并发安全的做法要高效。在JDK1.7中，使用分段锁机制来实现，在JDK8中，进行了大量的修改，采用了乐观锁加 synchronized 来实现。本文的主要哦学习JDK8下的ConcurrentHashMap的原理。本来我是打算看其他的博文来学习的。但是我看了很多博文，对于一些细节的地方总是一笔带过，对于一些实现原理也没有详细讲述，本篇文章主要是我学习的过程中，对一些细节问题和原理进行的详细的记录。
JDK1.8下的ConcurrentHashMap
概述
JDK8的ConcurrentHashMap其底层的实现原理和HashMap差不多。整体结构如下：
同样使用了链表和红黑树作为解决冲突的数据结构。解决并发的方法是采用CAS+ synchronized 的方法，具体怎么实现在代码中再看。
主要变量
/**
* 定义最大容量
*/
private static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The default initial table capacity. Must be a power of 2
* (i.e., at least 1) and at most MAXIMUM_CAPACITY.
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* 定义table表的最大长度，这个是为了防止locat的时候VM产生内存溢出。
* -8是因为留了header的长度。
*/
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 默认初始化容量
*/
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 默认负载因子
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 链表转为红黑树的长度阈值
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 红黑树退回链表的长度阈值
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 当容量没有超过这个值的时候，map不会进行树化而是先进行扩容，这个解决短数组链表过长问题的时候比
* 树化能够获得更大的性能提升
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 扩容的时候需要进行数据迁移，ConcurrentHashMap使用多线程的数据迁移，这个是每个线程迁移的步长，
* 最小是table数组的长度
*/
private static final int MIN_TRANSFER_STRIDE = 16;
/**
* The number of bits used for generation stamp in sizeCtl.
* Must be at least 6 for 32bit arrays.
*/
private static int RESIZE_STAMP_BITS = 16;
/**
* The maximum number of threads that can help resize.
* Must fit in 32 - RESIZE_STAMP_BITS bits.
*/
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
/**
* 默认等于16，先记住之后用到了再回来看
*/
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
/*
* hash值代表的特殊含义
*/
static final int MOVED = -1; //当前节点在移动中
static final int TREEBIN = -2; //当前节点为红黑树
static final int RESERVED = -3; // hash for transient reservations
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
/** CPU的核数 */
static final int NCPU = Runtime.getRuntime().availableProcessors();
/**
* 这个值比较重要，也比较复杂，有好几种状态。。。
* 构造的时候（调用构造方法）
* = 0，未设置（初始化会使用DEFAULT_CAPACITY默认大小）
* > 0,表示的table数组需要初始化的长度（必须是2的次幂）
* 初始化的时候（调用initTable方法），需要使用构造时候设置的值
* = -1 正在初始化
* > 0(初始化完了，= max(构造的时候的值, DEFAULT_CAPACITY) * 负载因子)，表示容器中存放key-value的阈值
* 其它值
* < -1,分为两部分，高15位是新容量的值，低16位(M)表示并行扩容线程数+1，具体在resizeStamp函数介绍。
*/
private transient volatile int sizeCtl;
/**
* [0, transferIndex)表示table数组中待移动的hash桶（主要用在扩容时）
*/
private transient volatile int transferIndex;
get操作
get(Object key)
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
//spread方法计算hash值，在HashMap中是hash()
int h = spread(key.hashCode());
//判断tabel是不是null，然后(n - 1) & h定位，拿出桶中的元素，开始遍历寻找
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
//如果第一个就是，那么直接返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
/**
* 什么情况node的hash会小于0呢？
* 表示这个数组正在扩容，然后利用find方法去找。
* 这里不止扩容，还有红黑树的判断也在里面
*/
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
//到这里要顺着链表往下找了
//这里红黑树的情况到底是怎么样排除的呢？
//红黑树的情况，其hash值是小于0的，为-2
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
get方法比较简单，而且我们在get操作的时候完全没有看到任何跟保证线程安全的操作有关的语句。
put操作
put(K key, V value)
public V put(K key, V value) {
return putVal(key, value, false);
}
putVal(…)
final V putVal(K key, V value, boolean onlyIfAbsent) {
//不支持插入空值
if (key == null || value == null) throw new NullPointerException();
//计算hash值
int hash = spread(key.hashCode());
// 用于计算key所在的链表（hash桶）中的key-value数（最后判断是否要改红黑树）
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//如果table为空，那么初始化table
if (tab == null || (n = tab.length) == 0)
//initTable()用来初始化table
tab = initTable();
//取出对应桶中的节点，如果为空，就直接加入，这个时候不需要加锁使用CAS操作将
//创建的节点插入到table[i].
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//如果当前节点正在扩容中，而且当前位置正在别转移
else if ((fh = f.hash) == MOVED)
//调用这个函数来帮组转移，多线程transfer就体现在这里。。。
tab = helpTransfer(tab, f);
else {
//到了这里就是正常情况下的添加了
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
//这个判断是当前节点是一个链表，使用链表的方式在链表末端插入
if (fh >= 0) {
//开始记录长度
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
//到这里说明是红黑树，调用红黑树的方法进行插入。
else if (f instanceof TreeBin) {
Node<K,V> p;
//由于已经是红黑树了，这里的binCount已经没有用了，
// 为了不影响后面的判断，将其设置为2
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
//插入完成之后判断当前链的长度，判断是否需要树化
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
//计数
addCount(1L, binCount);
return null;
}
注意：和HashMap不同，HashMap在put结尾会判断是否需要扩容，如果size大于了扩容的阈值就会进行扩容。而在ConcurrentHashMap中不是这样的，最后并没有判断扩容的语句。而是将扩容的逻辑放到了树化的那个函数中。总所周知，树化是一个阈值的，小于这个阈值就不会树化而是扩容。但是这个扩容只能由那个阈值决定。也就是说
扩容
上面也说了，扩容只会在树化的方法中被调用，调用场景如下：
//按照惯例，小于这个阈值不能树化，而是直接进行扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
//扩容的大小是两倍。
tryPresize(n << 1);
扩容的函数是tryPresize方法，传入的参数是当前size的两倍。下面来看看tryPresize方法：
tryPresize
private final void tryPresize(int size) {
//和构造函数一样
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
//如果sizeCtl>=0,表示此时table数组容量的阈值。如果此时是小于0的，代表有有线程正在扩容
//这个线程就可以不用参合了
while ((sc = sizeCtl) >= 0) {
//获取数组
Node<K,V>[] tab = table; int n;
//这里是代表初始化
if (tab == null || (n = tab.length) == 0) {
//n代表的是扩容后的容量
n = (sc > c) ? sc : c;
//利用CAS改变sizeCtl的值为-1，代表当前正在扩容中
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
//初始化新的数组（扩容后的）
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
//这个sc的值此时应该是n的0.75，由于n是容量，所以计算出阈值为sc
sc = n - (n >>> 2);
}
} finally {
//最后要更新sizeCtl
sizeCtl = sc;
}
}
}
//这里代表扩容了，n是table length，如果已经扩到最大了就不扩了。
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
//到这里表明还要扩容。如果我们在这个线程完成了初始化，那么这个就是不等的，就是为分离这种情况
else if (tab == table) {
//resizeStamp方法的返回值为高16位置0，第16位为1，低15位存放当前容量m，代表的2^m == n，设置为1的目的是，如果
//向左移动16位那么1回到最高位，此时可以保证其为负数，以为sizeCtl在<-1的时候，就是一个负数，这个是为了保证和sizeCtl一样
int rs = resizeStamp(n);
//sizeCtl<-1,分为两部分，高15位是新容量的值，低16位(M)表示并行扩容线程数+1
if (sc < 0) {
//这个就是待扩容后的数组
Node<K,V>[] nt;
//sizeCtl<-1,分为两部分，高15位是新容量的值，低16位(M)表示并行扩容线程数+1
//RESIZE_STAMP_SHIFT=16,MAX_RESIZERS=(1 << (32 - 16)) - 1=0xffff
//所以这里比较的是
//sc >>> RESIZE_STAMP_SHIFT) != rs：当前的容量是否和需要的容量一样了。必须要保证sizeCTL的高16位保存的是容量
//sc == rs + 1代表啥没搞懂？？？
//sc == rs + MAX_RESIZERS没搞懂
//nt = nextTable) == null 代表扩容还没开始，出现这种情况八成是第一个线程还没初始化，这时候不能去扩容
//transferIndex <= 0 待迁移的序号不能小于0
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
//这个线程开始加入到迁移的步骤中，将sc设置为sc+1，代表又有一个线程参数工作
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
//这个时候开始扩容，这个函数是用来做数据迁移的。明显，第一个线程开始transfer的
//时候，数组都还没有new出来呢。
transfer(tab, nt);
}
//这个时候代表自己不是第一开始迁移的线程，所以要设置，将SIZECTL设置为容量和(2-1)个线程正在工作
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
这个方法我写了超多的注释，对于理解大体的思路来说应该没有问题了。有一些小细节，我也没有搞懂，但是不影响整体的流程。这个函数主要完成了以下的过程：
-
和构造函数一样，对传入的大小进行了一样的处理。
-
判断sizeCtl，如果小于0，就什么都不做。
sizeCtl在上面的注释中有，这是一个非常重要的控制变量，如果sizeCtl<0,代表现在它正在被初始化或者扩容。当前线程就不用进行扩容了。
-
判断table是否为空，如果为空就要进行初始化，初始化的时候将sizeCtl置为-1，作为标志位
-
如果table不为空，那么判断sizeCtl得到大小，判断是否需要扩容。
-
else if (tab == table) 这个的判断成立说明正式进入到扩容的逻辑。
-
在扩容的逻辑中也是最难理解的一个部分。具体可以参看注释。
由于扩容是支持多线程来进行迁移的，通过判断if (sc < 0)，来确定当前线程是否是第一个开启数据迁移的线程，如果是就执行transfer(tab, null)，并将sizeCtl设置为高16位保存容量，底16位为2，代表 （2-1）个线程正在扩容。
如果不是第一个线程，那么执行transfer(tab, nt);这个方法，执行这个方法前将sizeCtl的线程数加1.
可以看到第一个线程执行transfer方法的时候，新数组还是空呢，所以这个数组是在transfer方法中被new出来的。
上面这些步骤，配合注释应该能理解整个扩容的过程。下面就要进入最难的数据迁移过程了。
数据迁移
完成数据迁移的方法是transfer方法
transfer
先上代码：
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// stride 在单核下直接等于 n，多核模式下为 (n>>>3)/NCPU，最小值是 16
// stride 可以理解为”步长“，有 n 个位置是需要进行迁移的，
// 将这 n 个任务分为多个任务包，每个任务包有 stride 个任务
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
//MIN_TRANSFER_STRIDE=16
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 翻译过来就是正在被迁移的 Node
// 这个构造方法会生成一个Node，key、value 和 next 都为 null，关键是 hash 为 MOVED
// 后面我们会看到，原数组中位置 i 处的节点完成迁移工作后，
// 就会将位置 i 处设置为这个 ForwardingNode，用来告诉其他线程该位置已经处理过了
// 所以它其实相当于是一个标志。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 当前线程是否需要继续寻找下一个可处理的节点
boolean advance = 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的值确定当前范围内下一个要处理的节点。
// advance 为 true 表示可以进行下一个位置的迁移了
// 简单理解结局：i 指向了 transferIndex，bound 指向了 transferIndex-stride
//可以说这个循环就是找到了开始迁移和结束迁移的过程，并且为下一个线程迁移做好了准备。
while (advance) {
int nextIndex, nextBound;
//如果自己负责的那个部分处理完了，或者所有的都结束了，那么跳出循环。
if (--i >= bound || finishing)
advance = false;
//表明这里transferIndex<0.
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//经过这个代码，TRANSFERINDEX记录的就是下一个线程的开始迁移的位置了，这里改了过后
//在多线程条件下另外的线程又可以开始从TRANSFERINDEX开始迁移了。
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
// 看括号中的代码，nextBound 是这次迁移任务的边界，注意，是从后往前
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
//完成了迁移
if (finishing) {
//将
nextTable = null;
// 将新的 nextTab 赋值给 table 属性，完成迁移
table = nextTab;
// 重新计算 sizeCtl：n 是原数组长度，所以 sizeCtl 得出的值将是新数组长度的 0.75
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 之前我们说过，sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2
// 然后，每有一个线程参与迁移就会将 sizeCtl 加 1，
// 这里使用 CAS 操作对 sizeCtl 进行减 1，代表做完了属于自己的任务
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
//这里设置finish是代表所有的操作都做完了，该进入上面的if (finishing)分支了。
finishing = advance = true;
i = n; // recheck before commit
}
}
//如果i处是空的，没有任何的节点，那么放入刚刚初始化过的ForwardingNode节点
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
//判断i处的节点是否是正在迁移中的节点，如果是说明当前节点已经被处理过了，这个时候需要重新计算i和bound了。所以重置advance为true
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
//排除以上的所有情况，说明这个位置该正式进行迁移了
//对该节点加锁，保证线程安全
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
//判断此处是链表，
//整个链表的迁移过程和JDK1.7中的迁移过程差不多
//原链表中的元素只会放到两个地方。所以将原链表一分为2.然后分别放到两个位置
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);
}
//将第一个链表放到i
setTabAt(nextTab, i, ln);
//第二个链表放到i+n
setTabAt(nextTab, i + n, hn);
//设置当前节点正在移动中
setTabAt(tab, i, fwd);
//设置为true，说明当前位置结束，开始下一个位置。
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;
}
}
//如果一份为2之后，发现节点数<8,那么将其转化为链表
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;
}
}
}
}
}
}
在分析代码之前，我们先解决一个问题，就是concurrentHashMap的多线程数据迁移时怎么完成的？
首先应当了解stride这个变量，这个是步长，指的是每个线程应当完成迁移的桶的数目。，一般来说如果这个步长等于原数组长度，那么就只有一个线程来完成这个事情。再来说说这个多线程执行的过程。迁移的过程可以这样说：
那么其他的线程是如何参与到数据迁移的呢，之前扩容的代码也说过，当sizeCtl<0的时候，线程是进不来的，所以扩容的线程只有一个，那么其他线程不会是通过扩容进来的。回到putValue方法中，可以看到helpTransfer(tab, f)，这样一个方法。这个方法之后再来说，它的java注释是这样说的：Helps transfer if a resize is in progress.
这样我们就了解了这个多线程扩容是怎么一回事，接下来就来说一说迁移的整体流程，配合着注释可以总结如下：
-
确定步长
-
通过判断table==null判断是否初始化，如果没初始化要先初始化
-
开启一个大循环，初始化i和bound为0.i代表迁移的开始值，bound代表此次迁移的边界，从后往前。然后每一次循环会有一个while循环去寻找下一个需要迁移的位置。具体可以看注释。
-
然后判断当前的位置是否整个数组的迁移工作是否已经全部完成了（不是当前线程的工作），通过if (i < 0 || i >= n || i + n >= nextn)来判定，如果已经完成了，那么设置好新数组，sizeCtl等等，就可以退出了。
否则对i位置的桶进行迁移
-
对i位置的桶进行迁移的过程和jDK1.7中的迁移差不多，而且和HashMap里面的迁移的差别也不大，都是通过将原来桶上的链表或者红黑树分为两个链表，然后分别放到各自的新的位置。在原节点放上一个ForwardingNode节点。
接下来对一些细节进行说明：
-
ForwardingNode节点是一个继承自Node的类，注释中说得很清楚。这也是正在被迁移中的类的hash值为-1的原因。我们在get的时候，如果hash值为-1，实际取出的是这种类型的节点。
-
advance的作用：这个变量特别重要，有价值好好的说一下：
advance的作用概括一点说就是指示当前线程是否完成了自己的任务。我们可以看到，第一次进入到while循环出来之后，advance的被设置为了false，那么在哪里会将其重新设置为true呢？
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) return; //这里设置finish是代表所有的操作都做完了，该进入上面的if (finishing)分支了。 finishing = advance = true; i = n; // recheck before commit } } //如果i处是空的，没有任何的节点，那么放入刚刚初始化过的ForwardingNode节点 else if ((f = tabAt(tab, i)) == null) advance = casTabAt(tab, i, null, fwd); //判断i处的节点是否是正在迁移中的节点，如果是说明当前节点已经被处理过了，这个时候需要重新计算i和bound了。所以重置advance为true else if ((fh = f.hash) == MOVED) advance = true; // already processed ........ advance = true;最上面一种都结束了就不说了，主要是下面3个，如果i处是空，那么advance=true开启下一次迁移，或者是当前节点正在被迁移，以及被迁移完成了，都要开始下一次迁移。
再回到while循环：
--i; nextIndex = transferIndex; if (U.compareAndSwapInt (this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) { // 看括号中的代码，nextBound 是这次迁移任务的边界，注意，是从后往前 bound = nextBound; i = nextIndex - 1; advance = false; }一般情况我们都是执行的这句话，我们通过分析源码可知TRANSFERINDEX的初始值就是transferIndex.所以这里面的这个compareAndSwapInt方法只有在第一次才能设置成功。所以说这个循环只在第一次执行会设置好bound已经设置好TRANSFERINDEX这个值方便后来的线程进行迁移。所以除了第一次，不同之外，之后的每一次循环都是在将i–，挨着迁移第i个桶。所以概括来说advance变量就是指当前线程的迁移工作是否已经完成了的意思。
其他方法
treeifyBin
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
//按照惯例，小于这个阈值不能树化，而是直接进行扩容
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
//扩容的大小是两倍。
tryPresize(n << 1);
//这种情况该树化了
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;
}
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
resizeStamp
static final int resizeStamp(int n) {
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
这个函数调用在扩容的函数中，resizeStamp方法的返回值为高16位置0，第16位为1，低15位存放当前容量m。具体有啥用，结合扩容的代码来看。
helpTransfer
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
//进一步判断这个节点是否是正在移动中的节点
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
//将容量的高16位置0，第16位置1.
int rs = resizeStamp(tab.length);
//判断sizeCtl<0,代表当前真正扩容当中
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
//和扩容方法里的那个判断一样，中间两个没搞懂，不过不影响
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//首先先设置SIZECTL，将库扩容线程加1
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
//调用transfer方法开始了数据迁移
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
这个方法是实现多线程迁移的关键。其他的线程正是调用这个方法参与到数据迁移中的。能看到扩容那个方法，然后再来看这个方法就很简单了。
总结
ConcurrentHashMap之所以说是线程安全的，我们可以看到，sizeCtl是实现线程安全一个超级重要的变量，它声明为volatile，并且在每次修改的时候都采用CAS的方式。然后在具体数据迁移的时候，会对当前桶节点进行加锁，通过以上的源码分析，可以看出ConcurrentHashMap的多线程安全就是通过CAS操作和加锁实现的。
看这个源码，总共花了3天时间，一步一步调试，对于每个值都自己去算一下，结合着别人的博客，一点一点解决自己的疑惑，最后终于理解了整个过程。所以告诫自己，看源码一定要沉下心，不怕麻烦，不怕花时间，这样才能真正理解到大师的编程水平。上面的代码很多都是自己去理解的，不知道对不对，如果不对，我会好好改正的。
借鉴了：https://hestyle.blog.csdn.net/article/details/105492111
3991
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
