1.addCount
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
private final void addCount(long x, int check) {
CounterCell[] as;
long b, s;
//1.counterCells不为null
//2.或者 x加到baseCount失败
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a;
long v;
int m;
boolean uncontended = true;
//as为null
//as长度小于1
//as[ThreadLocalRandom.getProbe() & m]为null
//as[ThreadLocalRandom.getProbe() & m].value+x失败
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;
}
//能走到这里，表明as不为null，as[ThreadLocalRandom.getProbe() & m].value+x成功
if (check <= 1){
return;
}
//计算个数
s = sumCount();
}
if (check >= 0) {
Node<K,V>[] tab, nt;
int n, sc;
//1.s>=sc (数组元素个数大于或者等于扩容阈值)
//2.table不为null
//3.table的length小于MAXIMUM_CAPACITY
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) { //sc小于0，说明有线程正在扩容，那么会协助扩容
//扩容结束或者扩容线程数达到最大值或者扩容后的数组为null或者没有更多的桶
//位需要转移，结束操作
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0){
break;
}
//扩容线程加1，成功后，进行协助扩容操作
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)){
transfer(tab, nt);
}
} else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2)){
//扩容
transfer(tab, null);
}
s = sumCount();
}
}
}
}
2.fullAddCount
初始化 counterCells，初始容量是2，将x放到要放入的位置；
如果没有冲突，放入该桶；
如果要放入的桶有冲突，重新生成hash，再看有没有冲突；
如果重新生成hash后，还是有冲突，将x增加到该桶的value；
如果有冲突，数组容量没有超过cpu核数，对数组进行扩容，新容量为老容量的2倍；
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
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;
//数组不为空，优先对数组中CouterCell的value累加
if ((as = counterCells) != null && (n = as.length) > 0) {
if ((a = as[(n - 1) & h]) == null) {//应该放入的桶为null
if (cellsBusy == 0) { // Try to attach new Cell
CounterCell r = new CounterCell(x); // Optimistic create
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs;
int m, j;
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;//放入桶
created = true;
}
} finally {
cellsBusy = 0;
}
if (created){ //放入成功
break;
}
continue; // Slot is now non-empty
}
}
collide = false;
} else if (!wasUncontended){ // CAS already known to fail
wasUncontended = true; // Continue after rehash
}
//x添加到a.value
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)){
break;
} else if (counterCells != as || n >= NCPU){
collide = false; // At max size or stale
} else if (!collide){
collide = true;
} else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
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
}
h = ThreadLocalRandom.advanceProbe(h);//重新计算hash
}
//CounterCell数组为空，并且没有线程在创建数组，修改标记，并创建数组
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
if (counterCells == as) {
//创建数组，容量为2
CounterCell[] rs = new CounterCell[2];
rs[h & 1] = new CounterCell(x);//这次的x保存至rs[h & 1]
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init){
break;
}
}
//数组为空，并且有别的线程在创建数组，那么尝试对baseCount做累加，
//成功就退出循环，失败就继续循环
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x)){
break; // Fall back on using base
}
}
}
}
