j.u.c ConcurrentHashMap addCount方法
j.u.c ConcurrentHashMap addCount方法
1、当总节点数量超过sizeCtl则对数组执行扩容操作； 将数组长度扩大为原来的2倍；
2、记录当前总节点的数量；
当添加、修改 元素都会触发判断数组是否需要扩容的操作：
sizeCtl作为判断是否对数组进行2倍扩容的依据；
sizeCtl= loaderFactor*当前数组长度；
一般loaderFactor=3/4.
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// hashCode 低16位异或高16位;
int hash = spread(key.hashCode());
// 单个数组单元中的链表长度， 如果是红黑树则直接是2
int binCount = 0;
for (Node[] tab = table;;) { // 没有判断条件
// f是Node类型
Node f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
// 初始化数组
tab = initTable();
// 当数组不为空， 且根据hash值确定的数组单元，是空的；
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 直接创建一个节点存放在该数组单元
if (casTabAt(tab, i, null,
new Node(hash, key, value, null)))
// 跳出for循环， 结束了。
break; // no lock when adding to empty bin
}
// 数组正在扩容； 则帮助扩容。根据数组单元中head节点判断是否在扩容；
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 如果没有扩容
else {
V oldVal = null;
// 用f对象做同步。只锁当前数组单元，则不锁其他的数组单元。
// 同一个数组单元，只允许一个线程添加/修改
// 我的猜测： 在对数组单元改动的时候一定是先用该单元中的head节点作为锁的。包括删除该单元head节点、扩表的时候重新安排该单元的链表元素的时候；
synchronized (f) {
// 如果f还是该单元中的head， 就可以继续修改/添加节点。
if (tabAt(tab, i) == f) {
if (fh >= 0) { // fh=f.hash 判断是链表。
// 该单元至少有一个元素； binCount记录的是在该单元中迭代的次数直到修改/添加完成。
binCount = 1;
// 遍历链表； e=f
for (Node e = f;; ++binCount) {
K ek; // ek element key ; f.key
// hash相等 && （key是同一个对象 or equals方法比较相等)
// 认定是同一个key； 则对val更新。
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
// 暂存e
Node pred = e;
// 取出下一个元素。
if ((e = e.next) == null) {
pred.next = new Node(hash, key,
value, null);
break;
}
}
}
else if (f instanceof TreeBin) {
Node p;
// 固定binCount=2
binCount = 2;
// 如果添加红黑树节点，该key已经存在，则修改val; 否则直接添加新节点。
if ((p = ((TreeBin)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
// binCount 记录了数组单元中的链表长度， 如果在没插入新节点前，链表长度是8; 不包括先插入的节点。则尝试将链表转成红黑树；或者对数组扩容。
if (binCount >= TREEIFY_THRESHOLD)
// i（index）数组index
treeifyBin(tab, i);
// 如果是修改，则返回修改前的val
if (oldVal != null)
return oldVal;
break;
}
}
}
//1、 数组扩容； 数组扩容的条件是啥？
addCount(1L, binCount);
return null;
}
1、当总节点数量超过sizeCtl则对数组执行扩容操作； 将数组长度扩大为原来的2倍；
2、记录当前总节点的数量；
// addCount(1L, binCount);
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
// 1、如果计数盒子(counterCells)不为空；如果check<=1,则啥都不做；
// 2、 如果计数盒子为空， 则对baseCount做+1操作；
//baseCount用来做元素size记录， 如果更新成功了， 则直接到执行2
// 3、如果计数盒子为空， 则对baseCount做+1操作失败了， 则进入；
// 虽然对baseCount做+1操作失败了,但是s=b+x却保留了下来；
// s记录了当前map中总共添加了多少节点。
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
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;
}
// 如果check<=1则啥都不做； binCount=1 说明是链表，且替换了head节点的val值； 或者是数组单元是空的， 添加新的head; 就不做数组扩容的操作了； binCount=1 就没必要对数据做扩容了。
if (check <= 1)
return;
// 用计数盒子保存所有总节点数量； 并返回总节点数量；
s = sumCount();
}
// 执行2
if (check >= 0) {
Node[] tab, nt; int n, sc;
// 如果该map添加的节点数大于 sizeCtl， 则执行数组扩容操作； 将数组的长度扩大为原来的2倍
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// 数组扩容方法。默认将数组长度扩容为原来的2倍。
transfer(tab, null);
s = sumCount();
}
}
}