熟悉AtomicLong的都知道，它通过CAS操作解决原子性问题，但是这个类的设计也还有一些确定，在高并发下大量线程会同时更新同一个原子变量，但由于同时只可能有一个线程更新成功，这就会造成大量线程竞争失败，失败后则会通过无限的循环不断的进行自旋重新尝试CAS操作，这样会导致大量浪费CPU的资源，所以jdk1.8之后新增了一个LongAdder来解决这个问题。
它采样的主要思想是分而治之，既然多个线程竞争一个资源，如果把一个资源分解为多个小资源，是不是就会解决性能的问题。
今天带着这个问题分析一下LongAdder的源码。
这个类继承自Striped64，内部有三个变量，分别是cells、base、cellsBusy，且三个变量都用volatile进行修饰，保证内存的可见性。
cells是一个数组，长度为2的幂次方，base是个最基础的值，通过cas更新，其实最后LongAdder的实际值是base的值和cells的值之和。cellsBusy通过cas进行自旋，在扩容或者创建cells的时候。
下面先看一段代码。
代码很简单，创建一个对象，然后加1，最后打印。
increment其实最终调用的还是add方法，只是入参为1.
先看86行的代码，第一次进来cells肯定为空，这点可以在Striped64里得到验证。
如果是单线程中使用LongAdder，则每次在调用方法casBase进行CAS操作时，是不存在竞争的，换言之，cells也会一值为空，那用此类也没有意义了。
多线程情况下，执行方法casBase进行cas操作失败时，则执行代码88行，在第一次执行时，as为空则会执行91行的代码，详情如下图：
/**
* Same as longAccumulate, but injecting long/double conversions
* in too many places to sensibly merge with long version, given
* the low-overhead requirements of this class. So must instead be
* maintained by copy/paste/adapt.
*/
final void doubleAccumulate(double x, DoubleBinaryOperator 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) {
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to attach new Cell
Cell r = new Cell(Double.doubleToRawLongBits(x));
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) ?
Double.doubleToRawLongBits
(Double.longBitsToDouble(v) + x) :
Double.doubleToRawLongBits
(fn.applyAsDouble
(Double.longBitsToDouble(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(Double.doubleToRawLongBits(x));
cells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
else if (casBase(v = base,
((fn == null) ?
Double.doubleToRawLongBits
(Double.longBitsToDouble(v) + x) :
Double.doubleToRawLongBits
(fn.applyAsDouble
(Double.longBitsToDouble(v), x)))))
break; // Fall back on using base
}
}这段代码主要完成了cells的初始化和扩容。
假设有多个线程同时执行到这个方法时，当第一线程执行到这个方法时，cells为空，则会执行61行的判断，即【else if (cellsBusy == 0 && cells == as && casCellsBusy())】
执行casCellsBusy成功，即把cellsBusy通过CAS操作修改为1，则开始进行cells的初始化，数组长度为2，最后把cellsBusy重新设置为0。初始化成功后，当前线程则退出for循环。即使多个线程同时执行到这里，但是cas只会成功一次。则第二个线程则会走到上述的76行逻辑，尝试对base进行CAS操作，如果执行成功，则同样退出for循环。
有一个重要的变量h，默认值为0，第一个线程执行到上述第4行时，会进行重置，在ThreadLocalRandom.current()里执行，这里会强制进行初始化，设置当前线程的值。代码如下：
注意208行的代码，跟进去之后也进行CAS操作。
刚提到h这个变量主要是用来计算在cells的落点，下面看下如果两个线程在同时一刻竞争到同一落点时的操作，继续跟进
假设两个线程都执行到了313行的代码，但是在执行316行的代码时，肯定只会有一个执行成功，因为casCellsBusy进行了CAS操作。则其中一个线程会完成设置，并把cellsBusy重新设置为0.则另外一个线程则会继续自旋，同样再次执行到313行代码时，发现此处不为空时，则会走到下面的代码：
这里尝试在a这个下标位置尝试CAS操作，如成功，则退出for循环。
如果失败则继续自旋。
这里定义了cells的长度不会超过cpu的个数，也就是说LongAdder的并行度为cpu的个数。
这里定义了cells的扩容条件及扩容长度，2的倍数。
在高并发下，因为有CAS操作，所以总会有一次cells的初始化和扩容，当计算下标发现此处的值不为空，则继续进行CAS操作，失败则自旋，总会有一次成功。
如何获取LongAdder的值，通过sum、longValue、intValue其实都可以，后两种方法本质也是调用的sum方法。
看下代码：
这里其实是base+cells的值然后进行累加。
看到这里，是不是觉着LongAdder比AtomicLong要牛逼多了。
最后再看下Cell
@sun.misc.Contended，这个用来解决伪共享。Cell内部的value也是内存可见的。今天的内容你看懂了么？LongAdder的好处多多，可以用起来了，哈哈。