LongAdder是Java并发包中的一个类，用于解决AtomicLong在高并发写时的性能问题。它通过将变量拆分为base和多个Cell，降低了并发写冲突，提高了并发性能。在添加值时，首先尝试CAS更新base，失败则更新Cell数组。当需要获取总和时，LongAdder会累加base和所有Cell的值，可能在并发环境下不精确。
图解java.util.concurrent并发包源码系列——LongAdder
往期文章：
- 人人都能看懂的图解java.util.concurrent并发包源码系列 ThreadPoolExecutor线程池
- 图解java.util.concurrent并发包源码系列，原子类、CAS、AtomicLong、AtomicStampedReference一套带走
上一次讲到如果我们高并发写的情况下使用原子类，比如AtomicLong，会存在大量的CAS更新失败，导致CPU一直空转。
要解决这种情况，我们可以使用LongAdder，本篇文章将会对LongAdder的作用、特点、原理以及源码等内容进行阐述。
LongAdder的作用和特点
LongAdder也是并发包里面的一个原子类，与AtomicLong同样位于java.util.concurrent.atomic这个包路径下。LongAdder与AtomicLong一样具有对一个变量进行原子更新的能力，而LongAdder与AtomicLong的不同之处在于LongAdder可以解决AtomicLong在高并发写的情况下大量CAS更新失败的问题。之所以AtomicLong会在高并发写的情况下大量的CAS更新失败，是因为AtomicLong内部只有一个变量，所有的线程都要竞争修改这个变量，因此在高并发写的情况下冲突就会很严重。于是LongAdder将原先的一个变量拆成了多份，提升了并发度，类似于分段的思想。
LongAdder的原理
LongAdder通过把一个变量拆成多份，从而降低并发写冲突。首先LongAdder有一个base变量，在并发写冲突不高的情况下，每一个线程过来，都会去更新这个base变量，一旦并发写冲突特别严重，此时CAS修改base变量会失败，那这种情况怎么办呢？
LongAdder还有一个Cell数组，每个Cell对象里面都有一个value变量，当并发写冲突非常严重，CAS修改base变量失败时，线程会转而去修改某个Cell数组里面的value变量，此时会为当前线程分配一个随机值probe，然后通过“probe & (Cell数组长度 - 1)”计算得出Cell数组下标，通过CAS更新该Cell对象里面的value值。
通过把原先AtomicLong的一个value变量，拆分成了一个base变量加一个Cell数组，提升了并发度，降低了并发写冲突的概率。
但是正因为做了变量拆分，所以当我们要获取LongAdder的值时，LongAdder就要做累加操作，把base和Cell数组里面所有Cell对象的value值相加，如果此时有别的线程对LongAdder进行写操作，那么就得到的值就不准确。
LongAdder源码
核心的成员变量
/**
* Cell数组
*/
transient volatile Cell[] cells;
/**
* 没有并发写冲突时会更新base值
*/
transient volatile long base;
/**
* 自旋锁(通过CAS锁定)，在调整cells大小或创建Cell时使用。
*/
transient volatile int cellsBusy;
三个重要的成员变量：
- base：base值，会在LongAdder没有并发写冲突的情况下通过CAS更新
- cells：Cell数组，在LongAdder并发写冲突严重的情况下，CAS更新base值会失败，此时线程会被分配一个Cell对象，通过CAS更新该Cell对象的value值
- cellsBusy：自旋锁，当需要创建Cell数组cells或者Cell数组扩容时，要加自旋锁，防止并发创建Cells数组或扩容
add方法
LongAdder的add方法接收一个long类型参数，会累加到LongAdder当中。
public void add(long x) {
Cell[] as; long b, v; int m; Cell a;
// casBase(b = base, b + x) 就是先尝试通过CAS更新base值，更新成功就不会进这个if分支
if ((as = cells) != null || !casBase(b = base, b + x)) {
boolean uncontended = true;
if (as == null || (m = as.length - 1) < 0 ||
// as[getProbe() & m] 就是给当前线程分配到的Cell对象，getProbe是获取一个随机值
(a = as[getProbe() & m]) == null ||
// a.cas(v = a.value, v + x))就是CAS更新分配到的Cell对象的value值
!(uncontended = a.cas(v = a.value, v + x)))
// 到这里，要么就是分配到的Cell对象是个null，要么就是CAS更新Cell对象也不成功
longAccumulate(x, null, uncontended);
}
}
用一张图表示上面这一段代码的流程：
首先会调用 casBase(b = base, b + x) 尝试通过CAS更新base值：
final boolean casBase(long cmp, long val) {
return UNSAFE.compareAndSwapLong(this, BASE, cmp, val);
}
casBase这个方法通过Unsafe这个类的compareAndSwapLong这个方法，更新base值，底层通过一条“Lock cmpxchg”汇编指令，调用到CPU的CAS指令，在硬件级别提供原子性保障。
如果CAS更新base值失败，那么接下来就要从Cell数组中给当前线程分配一个Cell对象，让当前线程尝试CAS更新Cell对象里面的value值。给当前线程分配Cell，首先要取得一个随机值，getProbe()这个方法就是获取一个随机值，然后通过 a = as[getProbe() & m] 取得Cell对象，as就是Cell对象数组cells，m是Cell数组的长度减一，取得一个Cell对象a，通过 a.cas(v = a.value, v + x) 使用CAS的方式尝试更新Cell对象的value值。
如果CAS更新Cell对象的value值也不成功，说明此时并发写冲突非常严重，那就要调用longAccumulate方法作进一步处理了。
longAccumulate方法
longAccumulate方法比较复杂，我们先不看代码，先看一张图，对这个方法的流程有一个大体的印象。
整个longAccumulate方法，就是一个自旋。
for循环里面，首先会判断Cell是否已初始化，如果未初始化，要先初始化Cell数组。那么会尝试获取执行锁并初始化Cell数组，如果获取自旋锁成功，那么初始化Cell数组长度为2，然后会顺便初始化当前线程对应的Cell对象，然后就会退出for循环，这一路顺利下来的话就结束了。
如果Cell数组未初始化，但是又获取不到自旋锁呢？那就尝试CAS更新一次base值，如果成功就退出for循环，如果不成功则进入下一轮循环。
如果Cell数组已经初始化了，那么会给当前线程分配一个Cell对象。如果该Cell对象为null，则当前线程尝试获取自旋锁，获取自旋锁成功，则初始化Cell对象，然后退出自旋，方法结束。
如果该Cell对象为null，当前线程尝试获取自旋锁不成功，则进入下一轮循环。
如果Cell对象不为null，则尝试CAS更新Cell对象value值，更新成功则退出循环，方法结束。
如果CAS更新失败，则要扩容Cell数组。当前线程会尝试获取自旋锁，获取自旋锁成功则扩容Cell数组为原数组长度的两倍大，然后进入下一轮循环；获取自旋锁不成功着直接进入下一轮循环。
下面就是longAccumulate方法的代码：
final void longAccumulate(long x, LongBinaryOperator fn,
boolean wasUncontended) {
int h;
// 获取当前线程的随机值
if ((h = getProbe()) == 0) {
ThreadLocalRandom.current();
h = getProbe();
wasUncontended = true;
}
boolean collide = false;
// 自旋
for (;;) {
Cell[] as; Cell a; int n; long v;
// 判断Cell数组是否已初始化
if ((as = cells) != null && (n = as.length) > 0) {
// as[(n - 1) & h] 重新给当前线程分配一个Cell对象，然后判断该Cell对象是否为null，为null进入if分支
if ((a = as[(n - 1) & h]) == null) {
// 进入当前if分支，说明分配给当前线程的Cell对象为null，需要初始化Cell对象
if (cellsBusy == 0) {
// 创建Cell对象
Cell r = new Cell(x);
// 首先要获取自旋锁cellsBusy
if (cellsBusy == 0 && casCellsBusy()) {
// 获取cellsBusy自旋锁成功
boolean created = false;
try {
Cell[] rs; int m, j;
// 这里再判断一次Cell对象是否为null，相当于是双重检测锁
if ((rs = cells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
// 赋值
rs[j] = r;
created = true;
}
} finally {
// 释放自旋锁
cellsBusy = 0;
}
if (created)
// 初始化Cell对象成功，退出循环
break;
continue;
}
}
collide = false;
}
else if (!wasUncontended)
wasUncontended = true;
// 进入下面这个else if分支，就是分配给当前线程的Cell对象不为null，那么可以尝试一次CAS
else if (a.cas(v = a.value, ((fn == null) ? v + x :
fn.applyAsLong(v, x))))
break;
else if (n >= NCPU || cells != as)
collide = false;
else if (!collide)
collide = true;
// 进入下面这个else if分支，说明CAS更新Cell对象的value值又不成功，并发冲突太严重，那就扩容Cell数组，casCellsBusy()是获取自旋锁
else if (cellsBusy == 0 && casCellsBusy()) {
try {
if (cells == as) {
// 扩容成原数组长度的两倍大
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;
}
h = advanceProbe(h);
}
else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
// 进入这个分支，说明Cell数组还未初始化，而且也没有其他线程对Cell数组进行初始化
boolean init = false;
try {
if (cells == as) {
// 初始化Cell数组，初始长度为2
Cell[] rs = new Cell[2];
// 顺便初始化当前线程的Cell对象
rs[h & 1] = new Cell(x);
cells = rs;
init = true;
}
} finally {
// 释放自旋锁
cellsBusy = 0;
}
if (init)
break;
}
// Cell数组未初始化，也获取不到自旋锁，那就尝试一次CAS更新base值
else if (casBase(v = base, ((fn == null) ? v + x :
fn.applyAsLong(v, x))))
break;
}
}
sum方法
public long sum() {
Cell[] as = cells; Cell a;
// base值赋值到sum
long sum = base;
if (as != null) {
// 遍历每一个Cell，value值累加到sum
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
// 返回sum
return sum;
}
LongAdder没有get方法，取而代之的是一个sum方法，也说明了获取LongAdder里面的值不像AtomicLong那样可以直接拿，而是要把所有值累加后再返回。如果中间有线程进行更新，那么返回的值就不准确，这也是使用LongAdder时要考虑的一个问题。
扫一扫
1514
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
