LongAdder源码分析(只分析了两个方法，add和longAccumulate，也是核心方法)

    public void add(long x) {

        Cell[] as; long b, v; int m; Cell a;

            if ((as = cells) != null || !casBase(b = base, b + x)) {//★三种情况，这里的cas只尝试一次，（在cells为空的情况下）失败就进去

                                                                        1.cells为空，cas（false||false）成功就不进去； 

                                                                        2.cells为空且casBase失败（false||true），要进去初始化cells     ▲

                                                                        3.cells不为空（true||{true|false}），肯定要进去尝试优化      ▲

            boolean uncontended = true;//★初始化未争用标识

            if (as == null || (m = as.length - 1) < 0 ||

                (a = as[getProbe() & m]) == null ||        //★获取当前线程的probe对应的cell，如果为空得初始化

                !(uncontended = a.cas(v = a.value, v + x)))//★uncontended这个是对线程对应的cell的值进行加一操作的结果，

                                                            冲突说明了什么？hash到同一个cell的多个线程同时操作cas，得进入下一个方法处理

                longAccumulate(x, null, uncontended);

        }

    }

    final void longAccumulate(long x, LongBinaryOperator fn,

                              boolean wasUncontended) {

        int h;

        if ((h = getProbe()) == 0) {//★第一次进入，如果hash为0，必须rehash

            //初始化ThreadLocalRandom;

            ThreadLocalRandom.current(); 

            //将h设置为0x9e3779b9

            h = getProbe();

            //设置未竞争标记为true

            wasUncontended = true;//★设置hash到同一个cell上并尝试cas这个cell的value时产生的竞争，竞争改value

        }

        boolean collide = false; //★修改cells起冲突了 

        for (;;) {

            Cell[] as; Cell a; int n; long v;

             if ((as = cells) != null && (n = as.length) > 0) {//★cell为空或者数组非空，可以尝试累加

                if ((a = as[(n - 1) & h]) == null) {//★这个cell还是virgin

                    if (cellsBusy == 0) {//★cellsbusy是个自旋锁，判断是否可以对cells数组进行操作

                        Cell r = new Cell(x); 

                        if (cellsBusy == 0 && casCellsBusy()) {//★获取该cell的自旋锁成功

                            boolean created = false;

                            try {

                                Cell[] rs; int m, j;

                                if ((rs = cells) != null &&

                                    (m = rs.length) > 0 &&

                                    rs[j = (m - 1) & h] == null) {//★再次检查是不是virgin

                                    rs[j] = r;                    //★ 将该插入的插入

                                    created = true;

                                }

                            } finally {

                                cellsBusy = 0;//★自旋锁放开，别人可以对cells数组进行修改操作了

                            }

                            if (created)//★爽完了，可以跳出了

                                break;

                            continue;//★没有获取锁，被别人爽了，继续循环

                        }

                    }

                    collide = false;//★有别的线程获取了这个cells数组的锁，不能改了，重置collide，继续下一个循环

                } else if (!wasUncontended)  

                    wasUncontended = true;//★修改cell的value竞争了，设置标志位，重新循环

                else if (a.cas(v = a.value, ((fn == null) ? v + x ://★特殊情况排除，就尝试累加cell，尝试成功就返回

                                             fn.applyAsLong(v, x))))

                    break;

                else if (n >= NCPU || cells != as)//★上一步争用失败，数组越界，或者cells被修改，重置冲突标志位

                    collide = false;

                else if (!collide)

                    collide = true;//★上面全部处理失败，肯定有冲突，将冲突标志位设置为true

                else if (cellsBusy == 0 && casCellsBusy()) {//★处理扩容（2倍）cells数组情况，获取了cellsbusy锁，并且他不忙

                    try {

                        if (cells == as) {      //★有可能人家改了，又释放了锁，检查cells还是不是以前那个数组

                            Cell[] rs = new Cell[n << 1];

                            for (int i = 0; i < n; ++i)

                                rs[i] = as[i];

                            cells = rs;

                        }

                    } finally {

                        cellsBusy = 0;

                    }

                    collide = false;

                    continue;           //★扩容完还得尝试累加value        // Retry with expanded table

                }

                h = advanceProbe(h);//★上面出问题的条件语句，都必须执行这里rehash

            }else if (cellsBusy == 0 && cells == as && casCellsBusy()) {//★未初始化且获取了cells的自旋锁就初始化

                boolean init = false;

                try {                           // Initialize table

                    //初始化cells数组，初始容量为2,并将x值通过hash&1，放到0个或第1个位置上

                    if (cells == as) {

                        Cell[] rs = new Cell[2];

                        rs[h & 1] = new Cell(x);

                        cells = rs;

                        init = true;

                    }

                } finally {

                    //解锁

                    cellsBusy = 0;

                }

                //如果init为true说明初始化成功，跳出循环

                if (init)//★初始化成功

                    break;

            }

            else if (casBase(v = base, ((fn == null) ? v + x :

                                        fn.applyAsLong(v, x))))//★最次的情况，只能在base上尝试累加了，也就退化成atomicLong类型了

                break;                          // Fall back on using base

        }

    }