private final void fullAddCount(long x, boolean wasUncontended) {//wasUncontended只有counterCells初始化之后，并且当前线程竞争修改失败，才会是false。其余情况都是true。
        int h;//h表示线程的hash值。
    //获取当前线程的hash值
        if ((h = ThreadLocalRandom.getProbe()) == 0) {//条件成立：说明当前线程还未分配hash值。
            ThreadLocalRandom.localInit();//给当前线程分配hash值      // force initialization
            h = ThreadLocalRandom.getProbe();//取出当前线程的hash值，赋值给h
            wasUncontended = true;//为啥这里强制设为true，当前线程肯定是写入到了countCells[0]位置,不把它当作一次真正的竞争。
        }
        boolean collide = false;   //标识是否有冲突，如果最后一个桶不是null，那么为true  //表示扩容意向 false一定不会扩容，true可能会扩容             // True if last slot nonempty
        for (;;) {//自旋
            CounterCell[] as; CounterCell a; int n; long v;//as表示counterCells引用，a表示当前线程命中的CounterCell，n表示counterCells数组长度，v表示期望值
　　　　　　 //数组不为空，优先对数组中CouterCell的value累加
        //CASE1:表示countCells已经初始化了，当前线程应该将数据写入到对应的CounterCell中。
            if ((as = counterCells) != null && (n = as.length) > 0) {
　　　　　　//2.如果a==null，也就是条件为true，说明当前线程对应下标的CountCell为空，那么就需要创建
            //3.true：表示cas失败，意味着当前线程对应的CountCell有竞争，那么就可能是重试或者扩容。这两种情况会进入到这个if判断中
            //线程对应的桶位为null
　　　　　　　　 //CASE1.1:a = as[(n - 1) & h]) == null true表示当前线程对应的下标位置的CounterCell为null，需要创建new CounterCell
                if ((a = as[(n - 1) & h]) == null) {
                    if (cellsBusy == 0) { //true：表示当前锁未被占用，false表示锁被占用           // Try to attach new Cell
                        CounterCell r = new CounterCell(x); // Optimistic create//创建CounterCell对象
　　　　　　　　　　　　　　　 //利用CAS修改cellBusy状态为1，成功则将刚才创建的CounterCell对象放入数组中
                    //条件一：true：表示当前锁未被占用，false表示锁被占用
                    //条件二：true：表示当前线程获取锁成功，false表示当前线程获取锁失败。
                        if (cellsBusy == 0 &&
                            U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                            boolean created = false;//是否创建成功的标记
                            try {               // Recheck under lock
                                CounterCell[] rs; int m, j;//rs表示当前countCells引用，m表示rs的长度，j表示当前线程命中的下标。
　　　　　　　　　　　　　　　　　　//桶位为空， 将CounterCell对象放入数组
                            //条件一条件二恒成立
                            // rs[j = (m - 1) & h] == null为了防止其它线程初始化过该位置，然后当前线程再次初始化该位置，导致数据丢失。
                                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;   //桶位已经被别的线程放置了已给CounterCell对象，继续循环        // Slot is now non-empty
                        }
                    }
                    collide = false;//将扩容意向改为false，原因是因为再CASE1.1中当前CounterCell都是为null，不可能不让写。因此不需要扩容。
                }
　　　　　　　　　　//桶位不为空，重新计算线程hash值，然后继续循环
            //CASE1.2：只有一种情况会来到这里，wasUncontended只有counterCells初始化之后，并且当前线程竞争修改失败，才会是false
                else if (!wasUncontended)       // CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
　　　　　　　　//重新计算了hash值后，对应的桶位依然不为空，对value累加
            //成功则结束循环
            //失败则继续下面判断
            //CASE1.3：当前线程rehash过hash值，然后新命中的CounterCell不为空。则来到这里。
            //true：写成功，退出循环，
            //false：表示rehash之后命中的新的cell也有竞争，重试1次  再重试一次
                else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
                    break;
　　　　　　　　 //数组被别的线程改变了，或者数组长度超过了可用cpu大小，重新计算线程hash值，否则继续下一个判断
            //CASE1.4:条件一：n >= NCPU true->表示扩容意向改为false，表示不扩容了。false说明counterCells数组还可以扩容
            //条件二：counterCells != as true表示其它线程已经扩容过了，当前线程rehash之后重试即可。
                else if (counterCells != as || n >= NCPU)
                    collide = false;            // At max size or stale
　　　　　　　　//当没有冲突，修改为有冲突，并重新计算线程hash，继续循环
            //CASE1.5  !collide=true，设置扩容意向为true，但是不一定真的发生扩容。因为一旦进入这里，那么又会rehash一下，又会重来。
                else if (!collide)
                    collide = true;
　　　　　　　　 //如果CounterCell的数组长度没有超过cpu核数，对数组进行两倍扩容
            //并继续循环
            //CASE1.6:真正扩容的逻辑
            //条件一：cellsBusy == 0 true表示当前无锁状态，当前线程可以去竞争这把锁。
            //条件二：U.compareAndSwapInt(this, CELLSBUSY, 0, 1)  true表示当前线程获取锁成功，可以执行扩容逻辑。
                                                            //false表示当前时刻有其它线程正在做扩容相关的操作。
                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值 rehash
            }
　　　　 //CounterCells数组为空，并且没有线程在创建数组，修改标记，并创建数组，因为前面CASE1是数组不为空，所以这里是数组为空
        //CASE2：当前条件countCells还未初始化，as为null
        //条件一：cellsBusy == 0  true表示当前未加锁
        //条件二：counterCells == as，为什么又重新比较一遍，明明前面CASE1已经赋值未null了。因为其它线程可能会在你给as赋值之后修改了counterCells。
        //条件三：如果未true，表示获取锁成功，会把cellsBusy改成1。false表示其它线程正在持有这把锁，那么当前线程就进不了这里面了。
            else if (cellsBusy == 0 && counterCells == as &&
                     U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                boolean init = false;
                try {                           // Initialize table
                    if (counterCells == as) {//为什么这里又判断了一下counterCells == as，防止其它线程已经初始化了，当前线程再次初始化，就会覆盖掉其它线程初始化的CountCell，导致丢失数据。
                        CounterCell[] rs = new CounterCell[2];//初始容量为2
                        rs[h & 1] = new CounterCell(x);
                        counterCells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy