ConcurrentHashMap源码分析
ConcurrentHashMap
ConcurrentHashMap是JDK1.5引入的一个并发安全且高效的HashMap，简单来说，我们可以认为它在HashMap的基础上增加了线程安全性的保障。
1.7 版本
在1.7版本中，ConcurrentHashMap由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。
一个ConcurrentHashMap里包含一个Segment数组。Segment的结构和HashMap类似，是一种数组和链表结构。一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁。Segment一旦初始化确定数组长度后，就不能再更改。
构造方法
- concurrencyLevel：用户估计的并发级别，就是说你觉得最多有多少线程共同修改这个map，根据这个来确定Segment数组的大小。默认是DEFAULT_CONCURRENCY_LEVEL = 16。可以理解为程序运行时能够同时更新ConccurentHashMap且不产生锁竞争的最大线程数，实际上就是ConcurrentHashMap中的分段锁个数，即Segment[]的数组长度。
- ssize：大于等于用户设置并发度的最小2幂指数作为实际并发度。（假如用户设置并发度为17，ssize则为32）
- sshift：sshift 等于 ssize从1向左移位的次数。因为MAX_SEGMENTS等于65536(2的16次方)，所以sshift最大值是16。
- Segment<K,V>[]：一旦初始化确定数组长度后，将不再更改。
- segmentShift：段偏移量。segmentShift用于定位参与散列运算的位数，segmentShift 等于32减sshift，segmentShift最小值是16。之所以用32减是因为ConcurrentHashMap里的hash()方法输出的最大数是32位。
- segmentMask：段掩码。等于 ssize减1，因为ssize的最大长度是65536，所以segmentMask最大值是65535，对应的二进制是16位，每位都是1。
- initialCapacity：初始化容量
- loadFactor：每个segment的负载因子
- cap：segment里HashEntry数组的长度，等于 initialCapacity除以ssize的倍数 c。如果c大于2(MIN_SEGMENT_TABLE_CAPACITY = 2)，就会取大于等于c的2的N次方值，所以segment里HashEntry数组的长度不是2，就是2的N次方。
get方法
- get操作先经过一次再散列，然后使用这个散列值通过散列运算定位到Segment(使用了散列值的高位部分)
- 再通过散列算法定位到table(使用了散列值的全部)
- ConcurrentHashMap 允许多个读操作并发进行，读操作并不需要加锁
- 整个get过程没有加锁，而是通过volatile保证get总是可以拿到最新值
put方法
ConcurrentHashMap 初始化的时候会初始化第一个槽 segment[0]，对于其他槽，在插入第一个值的时候再进行初始化。ensureSegment方法考虑了并发情况，多个线程同时进入初始化同一个槽 segment[k]，但只要有一个成功即可。
put方法会通过tryLock()方法尝试获得锁，获得了锁后 node为null进入try语句块，没有获得锁则调用scanAndLockForPut方法自旋等待获得锁
scanAndLockForPut方法里在尝试获得锁的过程中会对对应hashcode的链表进行遍历，如果遍历完仍找不到与key相同的HashEntry节点，则为后续的put操作提前创建一个HashEntry。当tryLock一定次数后仍无法获得锁，则通过lock申请锁。
- 在获得锁之后，Segment对链表进行遍历，如果某个HashEntry节点具有相同的key，则更新该HashEntry的value值。
- 否则新建一个HashEntry节点，采用头插法，将它设置为链表的新head节点并将原头节点设为新head的下一个节点。
- 新建过程中如果节点总数（含新建的HashEntry）超过threshold，则调用rehash()方法对Segment进行扩容，最后将新建HashEntry写入到数组中
rehash方法
- 扩容是新创建了数组，然后进行迁移数据，最后再将 newTable 设置给属性 table。
- 为了避免让所有的节点都进行复制操作：由于扩容是基于2的幂指来操作，假设扩容前某HashEntry对应到Segment中数组的index为i，数组的容量为capacity，那么扩容后该HashEntry对应到新数组中的index只可能为 i或者i+capacity，因此很多HashEntry节点在扩容前后index可以保持不变。
- 重置节点时，遍历旧table中所有节点，把最后不同index的节点数组及之后链表放到新table数组对应下标处；
- 再从头开始遍历到最后不同index节点，按头插法插入到新table对应下标的链表中。
size方法
- 首先自旋执行以下操作：循环所有的Segment，获得对应的值以及所有Segment的modcount之和。
- 在 put、remove 和 clean 方法里操作元素前都会将变量 modCount 进行变动，如果连续两次所有Segment的modcount和相等，则过程中没有发生其他线程修改ConcurrentHashMap的情况，返回获得的值。
- 当循环次数超过预定义的值时，这时需要对所有的Segment依次进行加锁，获取返回值后再依次解锁。所以一般来说，应该避免在多线程环境下使用size和containsValue方法。
1.8版本
改进
- 取消segments字段，直接采用transient volatile HashEntry<K,V>[] table保存数据，采用table数组元素作为锁，从而缩小了锁的粒度，进一步减少并发冲突的概率，并大量使用了采用了 CAS + synchronized 来保证并发安全性
- 将原先 table数组＋单向链表的数据结构，变为 table数组＋单向链表＋红黑树的结构。对于个数超过8(默认值)的列表，jdk1.8采用了红黑树结构，那么查询的时间复杂度可以降低到O(logN)，可以改进性能。
核心结构和属性
- Node：基本和1.7中的HashEntry相同，这个map本身所持有的也是一个Node型的数组。
- TreeNode：并不是直接转换为红黑树，而是把这些结点放在TreeBin对象中，由TreeBin完成对红黑树的包装
- TreeBin：负责TreeNode节点。在实际的ConcurrentHashMap数组中，存放的是TreeBin对象，而不是TreeNode对象。
- ForwardingNode：一个特殊的 Node 结点，hash 值为 -1，其中存储 nextTable 的引用。当 table 发生扩容时，ForwardingNode 作为一个占位符放在 table 中表示当前结点为 null 或者已经被移动。
- sizeCtl：用来控制 table 的初始化和扩容操作。
- 负数代表正在进行初始化或扩容操作
-1 代表正在初始化
-N 表示有N-1个线程正在进行扩容操作
0为默认值，代表当前table还没有被初始化
正数表示初始化大小或Map中的元素达到这个数量时，需要进行扩容
第一个线程扩容时会把sizeCtl修改为一个很大的负数，然后开始转移元素。如果在这个线程扩容的过程中有其他线程也来帮助扩容，那么sizeCtl就会加1，如果某个线程扩容结束后就会减1。
每个线程减 1 之后都会判断一下sizeCtl是否不等于之前那个很大的负数：如果等于则表示当前线程时扩容的最后一个线程，那么完成map属性的赋值工作；如果不等于并且又没有其他转移任务要做了，那么则退出转移方法。
构造方法
table的大小也必须是2的乘方数。
实际的初始化放在了插入元素的时候，如调用put、computeIfAbsent、compute等方法的时候，调用时检查table是否为null。
get方法
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
//计算hash值
int h = spread(key.hashCode());
//根据hash值确定节点位置
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;
}
//eh<0 说明这个节点在树上，调用树的find方法查找
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
//以上都不是，遍历链表找到对应的值返回
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
put方法
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key和value不能为NULL
if (key == null || value == null) throw new NullPointerException();
// key所对应的hashcode
int hash = spread(key.hashCode());
int binCount = 0;
// 通过自旋的方式插入数据
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 如果tab为空，则初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 算出数组下标，然后获取数组上对应下标的元素，如果为null，则通过cas来赋值
// 如果赋值成功，则退出自旋，否则是因为数组上当前位置已经被其他线程赋值了，进入下一次循环
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
}
// 如果数组当前位置的元素的hash值等于MOVED，表示正在进行扩容，当前线程也进行扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 对数组当前位置的元素进行加锁，该位置是Hash冲突的链表头结点或者红黑树根节点
synchronized (f) {
// 加锁后检查一下tab[i]上的元素是否发生了变化，如果发生了变化则直接进入下一次循环
// 如果没有发生变化，则开始插入新key,value
if (tabAt(tab, i) == f) {
// 如果tab[i]的hashcode是大于等于0的，代表是一个链表节点，将元素插入到链表尾部
if (fh >= 0) {
binCount = 1; // binCount表示当前链表上节点的个数，不包括新节点
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 遍历链表的过程中比较key是否存在一样的
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;
}
}
}
// 如果tab[i]是TreeBin类型，表示tab[i]位置是一颗红黑树
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// 在新插入元素的时候，如果不算这个新元素链表上的个数大于等于8了，那么就要进行树化
// 比如binCount为8，那么此时tab[i]上的链表长度为9，因为包括了新元素
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
// 存在key相同的元素
if (oldVal != null)
return oldVal;
break;
}
}
}
//Map数量+1，并检查是否需要扩容
addCount(1L, binCount);
return null;
}
总的来说，沿用了HashMap的put方法，根据hash值计算这个新插入的点在table中的位置i，如果i位置是空的，直接放进去，否则进行判断，如果i位置是树节点，按照树的方式插入新的节点，否则把i插入到链表的末尾(尾插法)。
整体流程上，首先定义不允许key或value为null的情况放入，对于每一个放入的值，首先利用spread方法对key的hashcode进行一次hash计算，由此来确定这个值在table中的位置。
如果这个位置存在结点，说明发生了hash碰撞，首先判断这个节点的类型：如果是链表节点,得到hash值相同节点组成的链表头节点。依次向后遍历确定这个新加入的值所在位置，如果遇到hash值与key值都与新加入节点是一致的情况，则只需要更新value值即可；否则依次向后遍历，直到链表尾插入这个结点。如果这个节点是树节点，直接调用树节点的插入方法进行插入新的值。
最后调用addCount方法，检查是否需要扩容。
初始化方法
构造方法并没有真正初始化，而是放在了ConcurrentHashMap插入元素的时候。
// 初始化数组
// 一个线程在put时如果发现tab是空的，则需要进行初始化
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// sizeCtl默认等于0，如果为-1表示有其他线程正在进行初始化，本线程不竞争CPU
// yield表示放弃CPU，线程重新进入就绪状态，重新竞争CPU，如果竞争不到就等，如果竞争到了又继续循环
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
// 通过cas将sizeCtl改为-1，如果改成功了则进行后续操作
// 如果没有成功，则表示有其他线程在进行初始化或已经把数组初始化好了
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 当前线程将sizeCtl改为-1后，再一次判断数组是否为空
// 会不会存在一个线程进入到此处之后，数组不为空了？
if ((tab = table) == null || tab.length == 0) {
// 如果在构造ConcurrentHashMap时指定了数组初始容量，那么sizeCtl就为初始化容量
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// 如果n为16，那么就是16-4=12
// sc = 3*n/4 = 0.75n, 初始化完成后sizeCtl的数字表示扩容的阈值
sc = n - (n >>> 2);
}
} finally {
// 此时sc为阈值
sizeCtl = sc;
}
break;
}
}
return tab;
}
扩容操作
当ConcurrentHashMap容量不足的时候，需要对table进行扩容。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// stride表示步长，步长最小为16，如果CPU只有一核，那么步长为n
// 既如果只有一个cpu,那么只有一个线程来进行扩容
// 步长代表一个线程负责转移的桶的个数
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
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表示第二个小数组的第一个元素的下标
transferIndex = n;
}
// 新数组的长度
int nextn = nextTab.length;
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// advance为true时，当前桶是否已经迁移完成，如果迁移完成则开始处理下一个桶
boolean advance = true;
// 是否完成
boolean finishing = false; // to ensure sweep before committing nextTab
// 开始转移一个步长内的元素，i表示
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
// i先减1,如果减完之后小于bound，那么继续转移
if (--i >= bound || finishing)
advance = false;
// transferIndex
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 通过cas来修改transferIndex，如果修改成功则对bound和i进行赋值
// 第一循环将进入到这里，赋值bound和i
// nextIndex就是transferIndex，假设为16，假如步长为4，那么就分为4个组，每组4个桶
// 0-3,4-7,8-11,12-15
// nextBound = 16-4=12
// i=16-1=15
// 所以bound表示一个步长里的最小的下标，i表示一个步长里的最大下标
// transferIndex是比较重要的，每个线程在进行元素的转移之前需要确定当前线程从哪个位置开始（从后往前）
// transferIndex每次减掉一个步长，表示当下一个线程准备转移元素时就可以从最新的transferIndex开始了
// 如果没有修改成功则继续循环
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// i表示一个步长里的最大下标, 如果i小于或者大于等于老数组长度，或者下标+老数组长度大于等等新数组长度
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 转移完成
if (finishing) {
nextTable = null;
table = nextTab;
// sizeCtl = 1.5n = 2n*0.75
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 每个线程负责的转移任务结束后利用cas来对sizeCtl减1
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 当前线程负责的任务做完了，同时还有其他线程还在做任务，则回到上层重新申请任务来做
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 当前线程负责的任务做完了，也没有其他线程在做任务了，那么则表示扩容结束了
finishing = advance = true;
i = n; // recheck before commit
}
}
// 从i位置开始转移元素
// 如果老数组的i位置元素为null,则表示该位置上的元素已经被转移完成了，
// 则通过cas设置为ForwardingNode，表示无需转移
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 如果i位置已经是ForwardingNode，则跳过该位置（就是桶）
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 加锁，开始转移
synchronized (f) {
// 加锁完了之后再次检查一遍tab[i]是否发生了变化
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
// fh大于等于0表示是链表
if (fh >= 0) {
// n是老数组的长度
// 因为n是2的幂次方数，所以runbit只有两种结果:0和n
int runBit = fh & n;
// 遍历链表，lastRun为当前链表上runbit连续相同的一小段的最后一段
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;
}
}
// 如果最后一段的runBit为0，则则该段应该保持在当前位置
// 否则应该设置到i+n位置
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
//从头节点开始，遍历链表到lastRun结束
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
// 如果ph & n，则将遍历到的节点插入到ln的前面
// 否则将遍历到的节点插入到hn的前面
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
// 将ln链表赋值在新tab的i位置
setTabAt(nextTab, i, ln);
// 将hn链表赋值在新tab的i+n位置
setTabAt(nextTab, i + n, hn);
// 这是老tab的i位置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;
}
}
}
}
}
}
为null或者已经处理过的节点，会被设置为forwardNode节点，当线程准备扩容时，发现节点是forwardNode节点，跳过这个节点，继续寻找未处理的节点，找到后对节点上锁。
如果这个位置是Node节点（fh>=0），说明它是一个链表，就构造一个反序链表，把他们分别放在nextTable的i和i+n的位置上。
如果这个位置是TreeBin节点（fh<0），也做一个反序处理，并且判断是否需要红黑树转链表，把处理的结果分别放在nextTable的i和i+n的位置上。
遍历过所有的节点以后就完成了复制工作，这时让nextTable作为新的table，并且更新sizeCtl为新容量的0.75倍，完成扩容。
并发扩容其实就是将数据迁移任务拆分成多个小迁移任务，在实现上使用了一个变量stride作为步长控制，每个线程每次负责迁移其中的一部分。
size方法
在扩容和addCount()方法就已经处理，Put函数里面就有addCount()函数，调用size的时候直接返回值。
private final void addCount(long x, int check) {
// 先通过CAS更新baseCount（+1）
// 如果更新失败则通过CAS更新CELLVALUE
// 如果仍然失败则调用fullAddCount
// as是一个CounterCell数组，一个CounterCell对象表示一个计数器，
// 多个线程在添加元素时，手写都会尝试去更新baseCount，那么只有一个线程能更新成功，另外的线程将更新失败
// 那么其他的线程就利用一个CounterCell对象来记一下数
CounterCell[] as; long b, s;
//
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
// 某个线程更新baseCount失败了
CounterCell a; long v; int m;
boolean uncontended = true;
// 如果CounterCell[]是null
// 或者CounterCell[]不为null的情况下CounterCell[]的长度小于1也就是等于0，
// 或者CounterCell[]长度不为0的情况下随机计算一个CounterCell[]的下标，并判断此下标位置是否为空
// 或者CounterCell[]中的某下标位置不为null的情况下通过cas修改CounterCell中的值失败了
// 才调用fullAddCount方法，然后返回
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
// 如果修改CELLVALUE成功了，这里的check就是binCount，这里为什么要判断小于等于1
if (check <= 1)
return;
// 如果修改CELLVALUE成功了，则统计ConcurrentHashMap的元素个数
s = sumCount();
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// 如果元素个数大于等于了阈值或-1就自旋扩容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// resizeStamp这个方法太难理解，反正就是返回一个数字，比如n=16,rs则=32795
int rs = resizeStamp(n);
// 如果sc小于0,表示已经有其他线程在进行扩容了，sc+1
if (sc < 0) {
// 如果全部元素已经转移完了，或者已经达到了最大并发扩容数限制则breack
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 如果没有，则sizeCtl加1，然后进行转移元素
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 如果sc是大于0的并且如果修改sizeCtl为一个特定的值，比如n=16, rs << RESIZE_STAMP_SHIFT) + 2= -2145714174
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// 转移元素，转移完了之后继续进入循环中
transfer(tab, null);
s = sumCount();
}
}
}
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
// 如果counterCells不等于空
if ((as = counterCells) != null && (n = as.length) > 0) {
// h可以理解为当前线程的hashcode，如果对应的counterCells数组下标位置元素当前是空的
// 那么则应该在该位置去生成一个CounterCell对象
if ((a = as[(n - 1) & h]) == null) {
// counterCells如果空闲
if (cellsBusy == 0) { // Try to attach new Cell
// 生成CounterCell对象
CounterCell r = new CounterCell(x); // Optimistic create
// 再次判断counterCells如果空闲，并且cas成功修改cellsBusy为1
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
// 如果counterCells对象没有发生变化，那么就将刚刚创建的CounterCell赋值到数组中
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
// 便是CounterCell创建成功
created = true;
}
} finally {
cellsBusy = 0;
}
// 如果CounterCell创建成功，则退出循环，方法执行结束
if (created)
break;
// 如果没有创建成功，则继续循环
continue; // Slot is now non-empty
}
}
// 应该当前位置为空，所以肯定没有发生碰撞
collide = false;
}
// 如果当前位置不为空，则进入以下分支判断
// 如果调用当前方法之前cas失败了，那么先将wasUncontended设置为true，
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
// 通过cas修改CELLVALUE的值，修改成功则退出循环，修改失败则继续进行分支判断
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
// counterCells发生了改变，或者当前counterCells数组的大小大于等于CPU核心数，设置collide为false，
// 如果到了这个极限，counterCells不会再进行扩容了
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
// 一旦走到这个分支了，那么就是发生了碰撞了，一个当前这个位置不为空
else if (!collide)
collide = true;
// 当collide为true进入这个分支，表示发生了碰撞会进行扩容
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
// 对counterCells进行扩容
if (counterCells == as) {// Expand table unless stale
CounterCell[] rs = new CounterCell[n << 1];
for (int i = 0; i < n; ++i)
rs[i] = as[i];
counterCells = rs;
}
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
// 重新进行hash
h = ThreadLocalRandom.advanceProbe(h);
}
// 如果counterCells等于空的情况下会走下面两个分支
// cellsBusy == 0表示counterCells没有线程在用
// 如果counterCells空闲，并且当前线程所获得counterCells对象没有发生变化
// 先通过CAS将cellsBusy标记改为1，如果修改成功则证明可以操作counterCells了，
// 其他线程暂时不能使用counterCells
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
// cellsBusy标记改成后就初始化CounterCell[]
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2];
// 并且把x赋值到CounterCell中完成计数
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
// 如果没有初始化成功，则证明counterCells发生了变化，当前线程修改cellsBusy的过程中，
// 可能其他线程已经把counterCells对象替换掉了
// 如果初始化成功，则退出循环，方法执行结束
if (init)
break;
}
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
在具体实现上，计算大小的核心方法是 sumCount
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
baseCount：记录容器数量
counterCells：记录CAS更新baseCounter值时，由于高并发失败的值
大致流程是：
- 对 baseCount 做 CAS 自增操作
- 如果并发导致 baseCount CAS 失败，使用 counterCells
- 如果 counterCells CAS 失败，在 fullAddCount 方法中，会继续死循环操作，直到成功。
常见问题
JDK7中的ConcurrentHashMap是怎么保证并发安全的？
主要利用Unsafe操作+ReentrantLock+分段思想。
主要使用了Unsafe操作中的：
- compareAndSwapObject：通过cas的方式修改对象的属性
- putOrderedObject：并发安全的给数组的某个位置赋值
- getObjectVolatile：并发安全的获取数组某个位置的元素
分段思想是为了提高ConcurrentHashMap的并发量，分段数越高则支持的最大并发量越高，程序员可以通过concurrencyLevel参数来指定并发量。ConcurrentHashMap的内部类Segment就是用来表示某一个段的。
每个Segment就是一个小型的HashMap的，当调用ConcurrentHashMap的put方法是，最终会调用到Segment的put方法，而Segment类继承了ReentrantLock，所以Segment自带可重入锁，当调用到Segment的put方法时，会先利用可重入锁加锁，加锁成功后再将待插入的key,value插入到小型HashMap中，插入完成后解锁。
JDK7中的ConcurrentHashMap的底层原理
ConcurrentHashMap底层是由两层嵌套数组来实现的：
- ConcurrentHashMap对象中有一个属性segments，类型为Segment[];
- Segment对象中有一个属性table，类型为HashEntry[];
当调用ConcurrentHashMap的put方法时，先根据key计算出对应的Segment[]的数组下标 j，确定好当前key,value应该插入到哪个Segment对象中，如果segments[j]为空，则利用自旋锁的方式在j位置生成一个Segment对象。
然后调用Segment对象的put方法。
Segment对象的put方法会先加锁，然后也根据key计算出对应的HashEntry[]的数组下标 i，然后将key,value封装为HashEntry对象放入该位置，此过程和JDK7的HashMap的put方法一样，然后解锁。
在加锁的过程中逻辑比较复杂，先通过自旋加锁，如果超过一定次数就会直接阻塞等等加锁。
JDK8中的ConcurrentHashMap是怎么保证并发安全的？
主要利用Unsafe操作+synchronized关键字。
Unsafe操作的使用仍然和JDK7中的类似，主要负责并发安全的修改对象的属性或数组某个位置的值。
synchronized主要负责在需要操作某个位置时进行加锁（该位置不为空），比如向某个位置的链表进行插入结点，向某个位置的红黑树插入结点。
JDK8中其实仍然有分段锁的思想，只不过JDK7中段数是可以控制的，而JDK8中是数组的每一个位置都有一把锁。
当向ConcurrentHashMap中put一个key,value时，
- 首先根据key计算对应的数组下标i，如果该位置没有元素，则通过自旋的方法去向该位置赋值。
- 如果该位置有元素，则synchronized会加锁
- 加锁成功之后，在判断该元素的类型
a. 如果是链表节点则进行添加节点到链表中
b. 如果是红黑树则添加节点到红黑树 - 添加成功后，判断是否需要进行树化
- addCount，这个方法的意思是ConcurrentHashMap的元素个数加1，但是这个操作也是需要并发安全的，并且元素个数加1成功后，会继续判断是否要进行扩容，如果需要，则会进行扩容，所以这个方法很重要。
- 同时一个线程在put时如果发现当前ConcurrentHashMap正在进行扩容则会去帮助扩容。
JDK7和JDK8中的ConcurrentHashMap的不同点
- JDK8中没有分段锁了，而是使用synchronized来进行控制
- JDK8中的扩容性能更高，支持多线程同时扩容，实际上JDK7中也支持多线程扩容，因为JDK7中的扩容是针对每个Segment的，所以也可能多线程扩容，但是性能没有JDK8高，因为JDK8中对于任意一个线程都可以去帮助扩容
- JDK8中的元素个数统计的实现也不一样了，JDK8中增加了CounterCell来帮助计数，而JDK7中没有，JDK7中是put的时候每个Segment内部计数，统计的时候是遍历每个Segment对象加锁统计。
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
