原子操作类LongAdder

LongAdder是一个原子性递增或者递减类，与AtomicLong的不同之处在于，LongAdder能够解决高并发情况下多线程同时竞争同意资源，而带来性能降低的问题。主要是通过将一个变量拆分为多个Cell,从而将单个变量的并发数分散到多个Cell上。关于LongAdder实现的几个分体如下：
(1)LongAdder 的结构是怎样的？
(2)当前线程应该出问Cell 数组里面的哪一个Cell元素？
(3)如何初始化Cell数组？
(4)Cell 数组如何扩容？
(5)线程访问分配的Cell元素有冲突后如何处理？
(6)如何保证线程操作被分配的Cell元素的原子性？

LongAdder的内部结构是LongAdder 继承Striped64实现Serializable，保证线程操作被分配的Cell元素的原子性可以看Cell的源码进行分析。

@sun.misc.Contended static final class Cell {
        volatile long value;
        Cell(long x) { value = x; }
        final boolean cas(long cmp, long val) {
            return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
        }

        // Unsafe mechanics
        private static final sun.misc.Unsafe UNSAFE;
        private static final long valueOffset;
        static {
            try {
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> ak = Cell.class;
                valueOffset = UNSAFE.objectFieldOffset
                    (ak.getDeclaredField("value"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }
    }

从源码中可以看到Cell类上的注解@sun.misc.Contended，用于防止伪共享的； volatile修饰的变量value,保证在多线程情况下value的内存可见性；cas方法保证当前线程更新是分配Cell元素中value的原子性。到这里问题1和6都已解决，下面就看看LongAdder类的递增或者递减方法的源码。

public void increment() {
        this.add(1L);
    }

    public void decrement() {
        this.add(-1L);
    }
    public void add(long x) {
        Cell[] as; long b, v; int m; Cell a;
        //(0)cells如果为null,则在运行casBase方法，在base上进行累加
        if ((as = cells) != null || !casBase(b = base, b + x)) {
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 || //(1)判断cells数组是非未空或者元素数量为0
                (a = as[getProbe() & m]) == null || // (2)通过as[getProbe() & m]确定当前线程使用哪个cell
                !(uncontended = a.cas(v = a.value, v + x))) //(3)执行Cell类中的cas方法，更新value的值
                longAccumulte(x, null, uncontended);//(4)
        }
    }
    
final boolean casBase(long cmp, long val) {
        return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
    }

从源码可以看到递增和递减方法调用的都是同一个方法add，从(2)处可以回答第二个问题，当前线程如和获取cell的。代码中还能发现LongAdder中的add方法中 Cell[] as元素是通过as = cells初始化得到的，而这个cells是在Striped64类中的属性；如果if条件都不满足的请况下如何初始化cells的呢？下面从longAccumulte这个方法找寻答案。

final void longAccumulate(long x, LongBinaryOperator fn,
                              boolean wasUncontended) {
        int h;
        if ((h = getProbe()) == 0) {
            ThreadLocalRandom.current(); // 初始化，在线程选择cells中的哪个cell是会用到
            h = getProbe();
            wasUncontended = true;
        }
        boolean collide = false;                // True if last slot nonempty
        for (;;) {
            Cell[] as; Cell a; int n; long v;
            if ((as = cells) != null && (n = as.length) > 0) { //cells不为空且有元素
                if ((a = as[(n - 1) & h]) == null) { // 给当前线程分配cell失败
                    if (cellsBusy == 0) {       // cellsBusy 标识位为0说明cells数组没有被初始化或者扩容
                        Cell r = new Cell(x);   // 给当前线程创建一个新的cell
                         //再次判断cellsBusy标识位为0 且源自操作成功
                        if (cellsBusy == 0 && casCellsBusy()) {
                            boolean created = false;
                            try {               
                          // 再次确认当前线程所在的cells数组中的位置没有cell,再将新建的cell放进相应的位置
                                Cell[] rs; int m, j;
                                if ((rs = cells) != null &&
                                    (m = rs.length) > 0 &&
                                    rs[j = (m - 1) & h] == null) {
                                    rs[j] = r;
                                    created = true;
                                }
                            } finally {
                                cellsBusy = 0;
                            }
                            if (created)
                                break;
                            continue;           // Slot is now non-empty
                        }
                    }
                    collide = false;
                }
                else if (!wasUncontended)       // CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
               //调用cell的cas方法，更新value值，fn为指定的计算逻辑，如果为空则使用默认的计算逻辑//v+x，如果不为空则使用指定的fn函数计算，从LongAdder的add方法上可以看到fn是null,所以在//LongAdder中使用的是默认的计算逻辑
                else if (a.cas(v = a.value, ((fn == null) ? v + x :
                                             fn.applyAsLong(v, x))))
                    break;
                else if (n >= NCPU || cells != as)
                    collide = false;            // At max size or stale
                else if (!collide)
                    collide = true;
                else if (cellsBusy == 0 && casCellsBusy()) {
                    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;                   // Retry with expanded table
                }
                //为了能够找到一个空闲的Cell ，重新计算hash值， xorshift 算法生成随机数，这样就可以解决分配cell的冲突问题
                h = advanceProbe(h);
            }
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
                boolean init = false;
                try {                           //初始化cells
                    if (cells == as) {
                        Cell[] rs = new Cell[2];
                        rs[h & 1] = new Cell(x);
                        cells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy = 0;
                }
                if (init)
                    break;
            }
            else if (casBase(v = base, ((fn == null) ? v + x :
                                        fn.applyAsLong(v, x))))
                break;                          // Fall back on using base
        }
    }

从上面的源码分析中可以解决问题3 4 5的问题。