LongAdder源码解析

短命女 2022-09-12 12:43 166阅读 0赞

# LongAdder源码 #

上一篇atomic原子类中对比了LongAdder、LongAccumulator 性能要比AtomicLong快

那么我们看一看LongAdder为什么这么快吧。

## 架构 ##

![image-20210907171758445][]

LongAdder是Striped64的子类

public class LongAdder extends Striped64 implements Serializable { 
        private static final long serialVersionUID = 7249069246863182397L;
       
    }

Striped64继承自Number

abstract class Striped64 extends Number {

### Striped64 ###

LongAdder是Striped64的子类

Striped64有几个比较重要的成员函数

`Striped64.java`

/** Number of CPUS, to place bound on table size CPU数量，即cells数组的最大长度 */
    static final int NCPU = Runtime.getRuntime().availableProcessors();
    
    /** * Table of cells. When non-null, size is a power of 2. cells数组，为2的幂，2,4,8,16.....，方便以后位运算 */
    transient volatile Cell[] cells;//最大值为CPU数量
    
    /**基础value值，当并发较低时，只累加该值主要用于没有竞争的情况，通过CAS更新。 * Base value, used mainly when there is no contention, but also as * a fallback during table initialization races. Updated via CAS. */
    transient volatile long base;
    
    /**创建或者扩容Cells数组时使用的自旋锁变量调整单元格大小（扩容），创建单元格时使用的锁。 1为加锁 * Spinlock (locked via CAS) used when resizing and/or creating Cells. */
    transient volatile int cellsBusy;

Striped64中一些变量或者方法的定义

![image-20210907173447887][]

其中最重要的两个变量是cells和base

![image-20210924203115219][]

#### Cell 累加单元 ####

是 java.util.concurrent.atomic 下 Striped64 的一个内部类

![image-20210907173509728][]

`cas(long prev, long next)` 方法 表示用 cas 方式进行累加, prev 表示旧值, next 表示新值

`@sun.misc.Contended`注解为了防止缓存行伪共享

#### **缓存行伪共享** ####

缓存与内存的速度比较

![image-20210912204426151][]

<table> 
 <thead> 
  <tr> 
   <th>从 cpu 到</th> 
   <th>大约需要的时钟周期</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>寄存器</td> 
   <td>1 cycle (4GHz 的 CPU 约为0.25ns)</td> 
  </tr> 
  <tr> 
   <td>L1</td> 
   <td>3~4 cycle</td> 
  </tr> 
  <tr> 
   <td>L2</td> 
   <td>10~20 cycle</td> 
  </tr> 
  <tr> 
   <td>L3</td> 
   <td>40~45 cycle</td> 
  </tr> 
  <tr> 
   <td>内存</td> 
   <td>120~240 cycle</td> 
  </tr> 
 </tbody> 
</table>

因为 CPU 与 内存的速度差异很大，如果每次都到内存中去读数据，那么时间都耗费在读取上了，

那么可以预读数据至缓存来提升效率。  
而缓存以缓存行为单位，每个缓存行对应着一块内存，一般是 64 byte（8 个 long）  
缓存的加入会造成数据副本的产生，即同一份数据会缓存在不同核心的缓存行中

CPU0使用这份数据，CPU1也使用这份数据、他们都会将数据读到各自的缓存中。

CPU 要保证数据的一致性，如果某个 CPU 核心更改了数据，其它 CPU 核心对应的整个缓存行必须失效 （64byte的数据都失效）

![image-20210912204619829][]

因为 Cell 是数组形式，在内存中是连续存储的，一个 Cell 为 24 字节（16 字节的对象头和 8 字节的 value），因  
此缓存行可以存下 2 个的 Cell 对象。这样问题来了：  
Core-0 要修改 Cell\[0\]  
Core-1 要修改 Cell\[1\]  
无论谁修改成功，都会导致对方 Core 的缓存行失效，比如 Core-0 中 Cell\[0\]=6000, Cell\[1\]=8000 要累加  
Cell\[0\]=6001, Cell\[1\]=8000 ，这时会让 Core-1 的缓存行失效  
@sun.misc.Contended 用来解决这个问题，它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的  
padding填充，从而让 CPU 将对象预读至缓存时占用不同的缓存行，这样，不会造成对方缓存行的失效

![image-20210912204713413][]

## LongAdder为什么这么快 ##

官网说明

![image-20210907171957149][]

当多个线程更新用于收集统计信息(而不是细粒度同步控制)等目的的公共和时,该类通常比AtomicLong更可取。在低更新竞争下,这两个类具有相似的特性。但在高争用情况下,该类的预期吞吐量明显更高,而代价是更高的空间消耗。

阿里Java开发手册

![image-20210907132620107][]

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

//获得long值的LongAdder.longValue()调用的是sum()
        public long longValue() { 
            return sum();
        }

sum()会将所有Cell数组中的value和base累加作为返回值，核心的思想就是将之前AtomicLong一个value的更新压力分散到多个value中去，从而降级更新热点。

Striped64内部有一个base变量，一个Cell\[\]数组。

base变量：非竞态条件下，直接累加到该变量上

Cell\[\]数组：竞态条件下，累加个各个线程自己的槽Cell\[i\]中

数学表达

sum= Base + ![image-20210907174640111][]

![image-20210907174648198][]

AtomicLong 基于 base + CAS自旋

5000W并发使用CAS就有几千W自旋的请求

LongAdder 基于base+cell\[\]

采用分散热点思想 ，将5000W并发分散到cell数组中

比如可以线程id对cell个数进行hash得到hash值，再根据hash值映射到这个数组cells的某个下标

然后获取值时，将各个槽中的结果累加返回 ，即 base+cell\[\]

其中cell\[\]大小为2的次幂，cell\[最大值为CPU核数

所以

并发低时 LongAdder 相当于AtomicLong =>base

并发高时LongAdder 相当于AtomicLong+cell数组=》base+cell\[\]

可以拿购物来举例，如果买的少就可用口袋装，口袋就是base

如果买的多了，口袋装不下，就要买购物袋装，购物袋就是cell数组

买的所有东西就是口袋装的加上购物袋装的==》sum=base+cell数组

## longAdder.increment()源码解读 ##

LongAdder在无竞争的情况，跟AtomicLong一样，对同一个base进行操作，当出现竞争关系时则是采用化整为零的做法，从空间换时间，用一个数组cells，将一个value拆分进这个数组cells。多个线程需要同时对value进行操作时候，可以对线程id进行hash得到hash值，再根据hash值映射到这个数组cells的某个下标，再对该下标所对应的值进行自增操作。当所有线程操作完毕，将数组cells的所有值和无竞争值base都加起来作为最终结果。

![image-20210907183507346][]

数学表达

![image-20210907173616479][]

对于自增的方法incremen

LongAdder longAdder = new LongAdder();
    
    public void add_LongAdder() { 
        longAdder.increment();
    }

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

increment调用的是add()方法

### add() ###

![1][]

#### 1当竞争不激烈，cells还未初始化 ####

public void add(long x) { //1
        // as 为累加单元数组
    	// b 为基础值
        Cell[] as; long b, v; int m; Cell a;
        // 进入 if 的两个条件
        // 1. as 有值, 表示已经发生过竞争, 初始化了cells，
        // 2. cas 给 base 累加时失败了, 表示 base 发生了竞争, 进入 if
        //此时cells未初始化，cells=null ；
        //casBase(b = base, b + x) cas操作能够成功
        if ((as = cells) != null || !casBase(b = base, b + x)) { //结果为(false||false)=》if条件不满足
            // uncontended= true 
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 || 
                (a = as[getProbe() & m]) == null ||
                !(uncontended = a.cas(v = a.value, v + x)))
                longAccumulate(x, null, uncontended);
        }
    }

`Striped64.java`

/** * CASes the base field. */
    final boolean casBase(long cmp, long val) { 
        return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
    }

此时竞争不激烈，cells还未初始化。用base就能完成累加操作，只更新base就可以了。

#### 2当竞争激烈，cells还未初始化 ####

public void add(long x) { //1
        Cell[] as; long b, v; int m; Cell a;
        //此时cells未初始化，cells=null ；
        //casBase(b = base, b + x) cas操作失败存在竞争 
        if ((as = cells) != null || !casBase(b = base, b + x)) { //(false||true)if条件满足
            boolean uncontended = true;//此时as为null 表示无竞争，当创建了as,并且cas操作失败才表示有竞争
             // as 还没有创建 as==null结果为true if条件满足
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[getProbe() & m]) == null ||
                !(uncontended = a.cas(v = a.value, v + x)))
                  // 进入 cell 创建的流程
                longAccumulate(x, null, uncontended);
        }
    }

##### longAccumulate() #####

`Striped64.java`

//传参 x为1 fn为null，wasUncontended为true
    final void longAccumulate(long x, LongBinaryOperator fn,
                              boolean wasUncontended) { 
        int h;
        //如果当前线程还没有对应的 cell, 强制初始化 随机生成一个 hash 值 用来后续将当前线程绑定到 cell
        if ((h = getProbe()) == 0) { 
            ThreadLocalRandom.current(); // force initialization强制初始化后getProbe()就有值了
            //每个线程都会初始化一个hash值
            h = getProbe();
            wasUncontended = true;
        }
        // collide 如果为 true 表示需要扩容 如果最后一个槽非空则为True
        boolean collide = false;                // True if last slot nonempty
        for (;;) { 
            Cell[] as; Cell a; int n; long v;
            // 此时cells为null if条件不满足
            //CASE1：cells已经被初始化则进入
            if ((as = cells) != null && (n = as.length) > 0) {    
                if ((a = as[(n - 1) & h]) == null) { 
                    if (cellsBusy == 0) {        // Try to attach new Cell
                        Cell r = new Cell(x);   // Optimistically create
                        if (cellsBusy == 0 && casCellsBusy()) { 
                            boolean created = false;
                            try {                // Recheck under lock
                                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
                
                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) {       // Expand table unless stale
                            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
                }
                h = advanceProbe(h);
            }
            
            //此时cells为null 所以cellsBusy = 0 处于无锁状态
            //cells 和 as 都为null
            //casCellsBusy()获取锁成功 将cellsBusy的值成功修改为1 处于持有锁状态
            //CASE2:cells没有加锁且没有初始化，则尝试对它进行加锁，并初始化cells数组
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) { 
                boolean init = false;
                try {                            // Initialize table 初始化cell数组
                    if (cells == as) { //cells == as双重判断
                   //不double check ，就有可能再次new一个cell数组，那么上一个线程对应数组中的值将会被篡改。即hash值变了 之前h&1，变成了h&3，值就不对应了
                        Cell[] rs = new Cell[2];  //第一次创建一个大小为2的cell数组rs
                        rs[h & 1] = new Cell(x);//hash运算(0/1) , 对cell的某个槽设置值1
                        cells = rs;//cells初始化完成
                        init = true;
                    }
                } finally { 
                    cellsBusy = 0;//释放锁 ，处于无锁状态了
                }
                if (init)//init=true 直接break返回 cells初始化完成
                    break;
            }
            //CASE3:cells正在进行初始化或扩容时（写不进cell数组时），则尝试直接在base上进行累加操作
            else if (casBase(v = base, ((fn == null) ? v + x :
                                        fn.applyAsLong(v, x))))
                break;                          // Fall back on using base
        }
    }

for(;;)自旋分为三个分支

CASE1:cell\[\]数组已经初始化

CASE2:cell\[\]数组未初始化(进行初始化)

CASE3:cell\[\]数组正在初始化或扩容时，尝试使用base进行累加

CASE2:cell\[\]数组未初始化(进行初始化)

如果条件都执行成功就会执行数组的初始化及赋值操作， Cell\[\] rs = new Cell\[2\]表示数组的长度为2，  
rs\[h & 1\] = new Cell(x) 表示创建一个新的Cell元素，value是x值，默认为1。  
h & 1类似于我们之前HashMap常用到的计算散列桶index的算法，通常都是hash & (table.len - 1)。同hashmap一个意思。

![image-20210907212358322][]

![image-20210907173447887][image-20210907173447887 1]

##### 线程hash值：Probe #####

![image-20210907212458933][]

`Striped64.java`

static final int getProbe() { 
        return UNSAFE.getInt(Thread.currentThread(), PROBE);
    }
    
    
    
     // Unsafe mechanics
        private static final sun.misc.Unsafe UNSAFE;
        private static final long BASE;
        private static final long CELLSBUSY;
        private static final long PROBE;//
        static { 
            try { 
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> sk = Striped64.class;
                BASE = UNSAFE.objectFieldOffset
                    (sk.getDeclaredField("base"));
                CELLSBUSY = UNSAFE.objectFieldOffset
                    (sk.getDeclaredField("cellsBusy"));
                Class<?> tk = Thread.class;
                PROBE = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomProbe"));//获得threadLocalRandomProbe的值
            } catch (Exception e) { 
                throw new Error(e);
            }
        }

Probe属于线程的hash值

方便后续对cells的长度进行hash确定值放到哪个槽内

`Thread.java`

/** Probe hash value; nonzero if threadLocalRandomSeed initialized */
    //Probe的hash值，如果threadLocalRandomProbe初始化了，则值为非零
    @sun.misc.Contended("tlr")
    int threadLocalRandomProbe;

当竞争激烈，cells还未初始化，就对cells进行初始化cell\[2\]，那么也就创建了两个槽位，并对其中一个槽位进行设置值1

#### 3当竞争激烈，cell\[2\]已经初始化 ####

##### cells设置值成功，一个槽设置了值，另一个槽还未设置值 #####

public void add(long x) { //1
        Cell[] as; long b, v; int m; Cell a;
        //此时cells[2]不为null if条件满足 此操作不对base进行累加
        if ((as = cells) != null || !casBase(b = base, b + x)) { 
            boolean uncontended = true;
            //as = cells !=null 结果为false
            //(m = as.length - 1) < 0 cells[2]即 2-1=1>0 结果为false
            if (as == null || (m = as.length - 1) < 0 ||
                //as[getProbe() & m]) 此时cells[2]只完成了初始化，并对某一个槽设置了值，
                //当hash到了未设置值的槽时 即 as[x] = null 结果为true if条件满足
                (a = as[getProbe() & m]) == null ||
                !(uncontended = a.cas(v = a.value, v + x)))
                // 进入 cell设置值的流程
                longAccumulate(x, null, uncontended);
        }
    }

`Striped64.java`

final void longAccumulate(long x, LongBinaryOperator fn,
                              boolean wasUncontended) { 
        int h;
        if ((h = getProbe()) == 0) { 
            ThreadLocalRandom.current(); // force initialization
            h = getProbe();
            wasUncontended = true;
        }
        boolean collide = false;                // True if last slot nonempty
        for (;;) { 
            Cell[] as; Cell a; int n; long v;
            //cells！= null 且cells.length>0 if条件满足
            if ((as = cells) != null && (n = as.length) > 0) { 
                //当某个槽的值为null，说明该cell没有被使用
                if ((a = as[(n - 1) & h]) == null) { 
                    //处于无锁状态 即cell[]没有正在扩容
                    if (cellsBusy == 0) {        // Try to attach new Cell
                        Cell r = new Cell(x);   // Optimistically create 创建一个cell单元
                        //casCellsBusy尝试加锁，获取锁成功 cellsBusy == 1
                        if (cellsBusy == 0 && casCellsBusy()) { //再次判断无锁状态
                            boolean created = false;
                            try {                // Recheck under lock 
                                Cell[] rs; int m, j;
                                //cells已经初始化 true
                                if ((rs = cells) != null &&
                                    //true
                                    (m = rs.length) > 0 &&
                                    //true
                                    rs[j = (m - 1) & h] == null) { 
                                    //将cells单元附到cell[]数组上 即该槽位的值设置为1.
                                    rs[j] = r;
                                    created = true;
                                }
                            } finally { 
                                //释放锁
                                cellsBusy = 0;
                            }
                            if (created)//created = true; break
                                break;
                            continue;           // Slot is now non-empty
                        }
                    }
                    collide = false;
                }
                else if (!wasUncontended)       // CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
                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) {       // Expand table unless stale
                            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
                }
                h = advanceProbe(h);
            }
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) { 
                boolean init = false;
                try {                            // Initialize table
                    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
        }
    }

上面代码判断当前线程hash后指向的数据位置元素是否为空。

如果为空则将cell数据放入数组中，然后跳出循环

##### 所有的槽都设置了值，后续会根据hash值来决定对哪个槽进行设置值 #####

public void add(long x) { 
        Cell[] as; long b, v; int m; Cell a;
        if ((as = cells) != null || !casBase(b = base, b + x)) { 
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[getProbe() & m]) == null ||
                //根据hash对某个槽进行cas操作 ，如果cas成功所有if条件不满足 返回 
                !(uncontended = a.cas(v = a.value, v + x)))
                longAccumulate(x, null, uncontended);
        }
    }

![image-20210907211154348][]

1.最初无竞争时只更新base；

2.如果更新base失败后，首次新建一个Cell\[\]数组

3.当多个线程竞争同一个Cell比较激烈时，可能就要对Cell\[\]扩容

#### 4当竞争激烈，cells进行cas操作失败 ####

多个线程同时命中一个cell的竞争

public void add(long x) { 
        Cell[] as; long b, v; int m; Cell a;
        if ((as = cells) != null || !casBase(b = base, b + x)) { 
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[getProbe() & m]) == null ||
                //根据hash对某个槽进行cas操作 ，如果cas失败，if条件满足 
                !(uncontended = a.cas(v = a.value, v + x)))
                //cells进入扩容
                longAccumulate(x, null, uncontended);//1,null,false
        }
    }

final void longAccumulate(long x, LongBinaryOperator fn,
                              boolean wasUncontended) { 
        int h;
        if ((h = getProbe()) == 0) { 
            ThreadLocalRandom.current(); // force initialization
            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) { 
                //cell[]所有槽都已经有了数据 if条件不满足
                if ((a = as[(n - 1) & h]) == null) { 
                    if (cellsBusy == 0) {        // Try to attach new Cell
                        Cell r = new Cell(x);   // Optimistically create
                        if (cellsBusy == 0 && casCellsBusy()) { 
                            boolean created = false;
                            try {                // Recheck under lock
                                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;
                }
               //add传过来的wasUncontended=false
               //cells已经发生竞争修改失败，wasUncontended为false 竞争激烈
                //CASE2
                else if (!wasUncontended)       // CAS already known to fail
                    //已经知道cas操作失败，进行重新尝试
                     //这里只是重新设置值为true 并h = advanceProbe(h);重置当前线程的hash 重新循环
                    wasUncontended = true;      // Continue after rehash
                //通过cas操作尝试对当前数中的value值进行累加x操作，x默认为1，如果cas成功则跳出循环
                //CASE3
                else if (a.cas(v = a.value, ((fn == null) ? v + x :
                                             fn.applyAsLong(v, x))))
                    break;
                //如果再次cas尝试也失败了
                //如果n大于CPU最大数量，不能再扩容了 并h = advanceProbe(h);重置当前线程的hash 重新循环
                //CASE4
                else if (n >= CPU || cells != as)
                    collide = false;            // At max size or stale
                //如果没有达到CPU上限，可以进行扩容 collide = true;并h = advanceProbe(h);重置当前线程的hash 重新循环
                //CASE5
                else if (!collide)
                    collide = true;
                //如果无锁状态且获得锁成功
                //CASE6
                else if (cellsBusy == 0 && casCellsBusy()) { 
                    try { 
                        //判断当前cells数组和最先赋值的as是不是同一个，true代表没有被其他线程扩容过
                        if (cells == as) {       // Expand table unless stale
                            //按位左移1位，即扩容为原来的两倍
                            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
                }
                //重置当前线程的hash 重新循环
                h = advanceProbe(h);
            }
            //CASE1
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) { 
                boolean init = false;
                try {                            // Initialize table
                    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
        }
    }

#### 总结 ####

![image-20210907225638150][]

## sum() ##

sum()会将所有Cell数组中的value和base累加作为返回值。  
核心的思想就是将之前AtomicLong一个value的更新压力分散到多个value中去，从而降级更新热点。

**为什么在并发情况下sum的值不精确**

/** * Equivalent to {@link #sum}. * * @return the sum */
    public long longValue() { 
        return sum();
    }

**sum执行时，并没有限制对base和cells的更新**(重点)。所以LongAdder不是强一致性的，它是最终一致性的。

首先，最终返回的sum局部变量，初始被复制为base，而最终返回时，很可能base已经被更新了，而此时局部变量sum不会更新，造成不一致。  
其次，这里对cell的读取也无法保证是最后一次写入的值。所以，sum方法在没有并发的情况下，可以获得正确的结果。

/** * Returns the current sum. The returned value is <em>NOT</em> an * atomic snapshot; invocation in the absence of concurrent * updates returns an accurate result, but concurrent updates that * occur while the sum is being calculated might not be * incorporated. * * @return the sum */
    //The returned value is <em>NOT</em> an atomic snapshot;
    //返回的值并不是一个原子性的快照
    public long sum() { 
        Cell[] as = cells; Cell a;
        long sum = base;
        if (as != null) { 
            for (int i = 0; i < as.length; ++i) { 
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

[image-20210907171758445]: /images/20220828/e7b28c97161f439cad94347e6690d7d4.png
[image-20210907173447887]: /images/20220828/e0be8bb90d244c9cb3e2ea9e27f94c71.png
[image-20210924203115219]: /images/20220828/a410e602eecc44bf879265ff589601c8.png
[image-20210907173509728]: /images/20220828/e4cab8cbcc004c05ba5c9145770dcac5.png
[image-20210912204426151]: /images/20220828/9b5195d6f239490f82a6aca66b12df0a.png
[image-20210912204619829]: /images/20220828/f3b64cf6eccd429b8ca5160e6f6b228c.png
[image-20210912204713413]: /images/20220828/c0de72ec4e0446d8818379ab64de6b9d.png
[image-20210907171957149]: /images/20220828/0ca05225969e416bae1334ec1b7401aa.png
[image-20210907132620107]: /images/20220828/48dedcf15ff04eb8ab413a071d16767b.png
[image-20210907174640111]: /images/20220828/2d3b3af8960f4a28b9f16d58cb8990bd.png
[image-20210907174648198]: /images/20220828/75bfe12ac6db4b20b9543c35098ec518.png
[image-20210907183507346]: /images/20220828/b03dec02cb4f45ee88925cd58329dc37.png
[image-20210907173616479]: /images/20220828/975526de1527459e9e7061cc8252598f.png
[1]: /images/20220828/23a2f03541584b9681483602d83ae6b0.png
[image-20210907212358322]: /images/20220828/fdb2f91d319248a5a1853e4ed062a508.png
[image-20210907173447887 1]: /images/20220828/dcb88357286248808a348254dfb94559.png
[image-20210907212458933]: /images/20220828/fce8147a0b124a5c8fc27e91fad118c4.png
[image-20210907211154348]: /images/20220828/670bc0c2539e4d46aab9008c6265309a.png
[image-20210907225638150]: /images/20220828/518983d78c6a40c6a0dffb66802809be.png