ConcurrentHashmap的addCount(1)

final V putVal(K key, V value, boolean onlyIfAbsent) {

...

//高并发下的扩容

//如何保证addCount的数据安全性以及性能

//将当前ConcurrentHashMap的元素数量加1，有可能触发transfer操作(扩容)

addCount(1L, binCount);

return null;

}

/**
  * 在putVal最后调用addCount的时候，传递了两个参数，分别是1和binCount(链表长度)
  * x表示这次需要在表中增加的元素个数，check参数表示是否需要进行扩容检查，大于等于0都需要进行检查
 */
private final void addCount(long x, int check) {

        CounterCell[] as; long b, s;

        /**
          * 判断counterCells是否为空，

          * 1. 如果为空，就通过cas操作尝试修改baseCount变量，对这个变量进行原子累加操作(做这个操作的意义是：如果在没有竞争的情况下，仍然采用baseCount来记录元素个数)

          * 2. 如果cas失败说明存在竞争，这个时候不能再采用baseCount来累加，而是通过CounterCell来记录
         */
        if ((as = counterCells) != null ||
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            CounterCell a; long v; int m;

            //是否冲突标识，默认为没有冲突
            boolean uncontended = true;

            这里有几个判断

            //1. 计数表为空则直接调用fullAddCount

            //2. 从计数表中随机取出一个数组的位置为空，直接调用fullAddCount

            //3. 通过CAS修改CounterCell随机位置的值，如果修改失败说明出现并发情况（这里又用到了一种巧妙的方法），调用fullAndCount

            //Random在线程并发的时候会有性能问题以及可能会产生相同的随机数,ThreadLocalRandom.getProbe可以解决这个问题，并且性能要比Random高
            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;
            }

            //链表长度小于等于1，不需要考虑扩容
            if (check <= 1)
                return;

            //统计ConcurrentHashMap元素个数
            s = sumCount();
        }
        if (check >= 0) {
            Node<K,V>[] tab, nt; int n, sc;
            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))
                    transfer(tab, null);
                s = sumCount();
            }
        }
    }