LongAdder源码解析

一、前言

    JDK1.8时，java.util.concurrent.atomic包中提供了一个新的原子类：LongAdder。LongAdder在高并发的场景下会比AtomicLong 具有更好的性能，代价是消耗更多的内存空间。

二、提出问题

1. 为什么要引入LongAdder？ 
2. LongAdder快在哪里？ 
3. 如果低并发环境下，LongAdder和AtomicLong性能差不多，那LongAdder是否就可以替代AtomicLong了？

为什么要引入LongAdder？

我们知道，AtomicLong是利用了底层的CAS操作来提供并发性的，比如getAndAdd方法：

//先获取旧值然后再旧值上加上指定值，利用的unsafe内部方法
public final long getAndAdd(long delta) {
    return unsafe.getAndAddLong(this, valueOffset, delta);
}

    上述方法调用了Unsafe类的getAndAddLong方法，该方法是个native方法，它的逻辑是采用自旋的方式不断更新目标值，直到更新成功。在并发量较低的环境下，线程冲突的概率比较小，自旋的次数不会很多。但是，高并发环境下，N个线程同时进行自旋操作，会出现大量失败并不断自旋的情况，此时AtomicLong的自旋会成为瓶颈。这就是LongAdder引入的初衷：解决高并发环境下AtomicLong的自旋瓶颈问题。

LongAdder快在哪里？

    我们知道，AtomicLong中有个内部变量value保存着实际的long值，所有的操作都是针对该变量进行。也就是说，高并发环境下，value变量其实是一个热点，也就是N个线程竞争一个热点。

    LongAdder的基本思路就是分散热点，将value值分散到一个数组中，这个数组是他的父类Striped64类的一个变量transient volatile Cell[] cells，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，这样热点就被分散了，冲突的概率就小很多。如果要获取真正的long值，只要将各个槽中的变量值累加返回。

举个例子：
比如3个线程对变量sum = 0进行三次累加，每次加1.
则LongAdder是根据Cell[] cells数组
比如线程1在index0,也就是base中，线程2为index1，线程3为index2，每个位置的元素为1，即cells = [1,1,1]。
那么longAdder的值就遍历整个cells数组，任何累加就得到其最终值3.

那LongAdder是否就可以替代AtomicLong了？

    LongAdder提供的API和AtomicLong比较接近，两者都能以原子的方式对long型变量进行增减。但是AtomicLong提供的功能其实更丰富，尤其是addAndGet、decrementAndGet、compareAndSet这些方法。

    addAndGet、decrementAndGet除了单纯的做自增自减外，还可以立即获取增减后的值，而LongAdder则需要做同步控制才能精确获取增减后的值。如果业务需求需要精确的控制计数，做计数比较，AtomicLong也更合适。

    一句话来说，低并发、一般的业务场景下AtomicLong是足够了。如果并发量很多，存在大量写多读少的情况，那LongAdder可能更合适，毕竟适合的才是最好的。

三、源码解析

继承了哪些类

    由上图可知LongAdder继承了Striped64类的Serializable接口，LongAdder的很多方法都是基于他的父类Striped64类。

Striped64类中的两个核心变量

//用来存放各个线程更改的值，当非空时，size是2的幂。
transient volatile Cell[] cells;
//基本值，主要在没有争用时使用，但也可作为表初始化竞争期间的回退，通过CAS更新
transient volatile long base;

Striped64类中的Cell内部类

//@sun.misc.Contended作用伪防止伪共享
@sun.misc.Contended static final class Cell {
    //存放long值的变量
    volatile long value;
    //构造方法
    Cell(long x) { 
        value = x; 
    }
        
    //CAS方法
    final boolean cas(long cmp, long val) {
        return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
    }

    // Unsafe mechanics
    //unsafe常量，设置为使用Unsafe.compareAndSwapInt进行更新
    private static final sun.misc.Unsafe UNSAFE;
    //Long的值在内存地址的偏移量
    private static final long valueOffset;
    static {
        try {
            //实例化UNSAFE对象
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> ak = Cell.class;
            //获取valueOffset的偏移量
            valueOffset = UNSAFE.objectFieldOffset(ak.getDeclaredField("value"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

LongAdder的构造方法

//LongAdder只有一个无参的构造方法
public LongAdder() {
}

LongAdder的一些常用方法

① increment()方法 和 decrement()方法。

//自增，利用add方法
public void increment() {
    add(1L);
}

//自减，利用add方法
public void decrement() {
    add(-1L);
}

    由上面可知，increment()方法 和 decrement()方法都是通过add方法来进行操作的，那么add方法的源码是怎么实现的呢？下面我给到了add方法的源码的实现，并且上面写了注释，应该挺好理解的。

public void add(long x) {
    Cell[] as; long b, v; int m; Cell a;
    /**
     * 1.先判断cells数组有没有初始化
     * 2.然后用casBase来对base偏移量进行CAS操作，如果没有线程竞争就更新成功然后退出
     * 3.若有线程竞争，则进入下一个if，uncontended是表示无竞争的意思
     */
    if ((as = cells) != null || !casBase(b = base, b + x)) {
        boolean uncontended = true;
        /**
         *  as == null || (m = as.length - 1) < 0 表示如下：
         * 先判断as也就是cells数组有没有进行初始化，如果没有初始化就直接进入longAccumulate方法初始化
         */
        if (as == null || (m = as.length - 1) < 0 ||
            /**
             * a = as[getProbe() & m]) == null表示如下：
             * 1.先根据线程的hash值(getProbe()方法表示获取其线程hash值)& m得到index
             * 2.然后判断此数组下标中是否有元素，如果没有元素就直接进入longAccumulate方法
             */
            (a = as[getProbe() & m]) == null ||
            /**
             * !(uncontended = a.cas(v = a.value, v + x))表示如下：
             * 1.若有元素，则通过CAS将需要加上的值x加到此数组下标上
             * 2.若CAS返回失败则直接进入longAccumulate方法
            */
            !(uncontended = a.cas(v = a.value, v + x)))

            //处理涉及初始化、调整大小、创建新单元格和/或争用的更新情况。
            //这种方法遇到了乐观重试代码常见的非模块化问题，它依赖于重新检查的读集。
            longAccumulate(x, null, uncontended);
    }
}

② sum()方法。

//累加和，获取LongAdder的最终结果
public long sum() {
    Cell[] as = cells; Cell a;
    long sum = base;
    if (as != null) {
        //通过遍历cells数组，然后累加各个下标上的值得到最终的结果
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

③ reset()方法。

//重置方法，将cells中的元素变为0
public void reset() {
    Cell[] as = cells; Cell a;
    base = 0L;
    if (as != null) {
        //遍历cells数组，将各个下标中的元素的值变为0
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                a.value = 0L;
        }
    }
}

④ sumThenReset()方法。

//得到最终结果后重置cells数组
public long sumThenReset() {
    Cell[] as = cells; Cell a;
    long sum = base;
    base = 0L;
    if (as != null) {
        //遍历cells数组，将各个下标上的元素的值累加，并且置为0
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null) {
                sum += a.value;
                a.value = 0L;
            }
        }
    }
    return sum;
}

四、总结

    LongAdder类与AtomicLong类的区别在于高并发时前者将对单一变量的CAS操作分散为对数组cells中多个元素的CAS操作，取值时进行求和；而在并发较低时仅对base变量进行CAS操作。