基于JAVA8-ConcurrentHashMap的putVal和addCount方法的学习总结

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 判断是链表，如果是红黑树的话，hash值为-2，这个在treeBin的构造方法中可以看见
// 该单元至少有一个元素； 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;
                                }
                            }
                        }
                        //如果是红黑树的话，hash值为-2，这个在treeBin的构造方法中可以看到
                        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;
    }

addCount方法的主要内容：
1、当总节点数量超过sizeCtl则对数组执行扩容操作； 将数组长度扩大为原来的2倍；
2、记录当前总节点的数量；

 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);//当n=16时，rs=32795
                // 如果正在扩容
                if (sc < 0) {
                // 扩容已经结束，中断循环
                // 如果 sc 的高 16 位不等于 标识符（如果扩容完成了，那么rs的值就会发生变化，因为n由16变成32了，那么rs（标识符）也会变化）
                // 如果 sc == 标识符 + 1 （扩容结束了，不再有线程进行扩容）（默认第一个线程设置 sc ==rs 左移 16 位 + 2，当第一个线程结束扩容了，就会将 sc 减一。这个时候，sc 就等于 rs + 1）
                // 如果 sc == 标识符 + 65535（帮助线程数已经达到最大）
                // nextTable 表示的是扩容新建的数组，如果nextTable 为null，表示已经转到扩容完成，nextTable已经被置为空
                // transferIndex 是数组分配索引，多线程扩容的基础，transferIndex <= 0表示需要转移的数组已经被分配完了
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                        break;
                    // 如果可以帮助扩容，那么将 sc 加 1. 表示多了一个线程在帮助扩容
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                        transfer(tab, nt);
                }
                // 触发扩容（第一个进行扩容的线程）
                // 如果不在扩容，将 sc 更新：标识符左移16位，然后 + 2. 也就是变成一个负数（从resizeStamp方法中可以推断出来，最高位为1）。高 16 位是标识符，低 16 位初始是2=1+1，其中一个1表示初始状态，另一个1表示有一个线程正常扩容.
                //SIZECTL之前代表阀值，更改后高16位为标识，低16位为扩容线程数加一，为负数，表示正在扩容
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
					//开始扩容。默认将数组长度扩容为原来的2倍。
					//第二个参数为null会初始化新数组nextTable，确保只有一个线程新建table
                    transfer(tab, null);
                s = sumCount();
            }
        }
    }

参考：
https://www.jianshu.com/p/749d1b8db066
https://blog.csdn.net/jupiter_888/article/details/103852735