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<K,V>[] tab = table;;) { // 没有判断条件

// f是Node类型
            Node<K,V> 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<K,V>(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<K,V> 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<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;
// 如果添加红黑树节点，该key已经存在，则修改val; 否则直接添加新节点。
                            if ((p = ((TreeBin<K,V>)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<K,V>[] 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();
            }
        }
    }