高并发累加器Striped64
Striped64主要用于支持并发累加器的实现。这个类在高并发环境下被用来做某种计数，【其设计的核心思想是在竞争激烈的时候尽量分散竞争】。
为了达到这一目标，Striped64维护了一个base Count和一个Cell数组。在多线程环境中，当一个线程想要更新计数时，它会首先试图更新base变量。如果成功，则该线程退出计数；否则，由于竞争激烈，该线程会转向Cell数组来分散计数。
Striped64根据线程来计算哈希，然后将不同的线程分散到不同的Cell数组的index上。在这个基础上，这个线程的计数内容就会被保存在该Cell的位置上。最后，为了得到总的计数结果，需要将base值与散落在Cell数组中的所有计数内容进行合并。
高并发下的累加器，两个实现类：LongAdder和DoubleAdder，基本上把longAccumulate方法搞清楚，就都能看懂了。
先来看一下内部类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中的value操作只能使用CAS（Compare-and-Swap）操作，因此一定是线程安全的。@sun.misc.Contended解决了伪共享的问题。
几个重要的成员变量：
/** Number of CPUS, to place bound on table size */
// CPU数量
static final int NCPU = Runtime.getRuntime().availableProcessors();
/**
* Table of cells. When non-null, size is a power of 2.
*/
// cell数组
transient volatile Cell[] cells;
/**
* Base value, used mainly when there is no contention, but also as
* a fallback during table initialization races. Updated via CAS.
*/
// base变量
transient volatile long base;
/**
* Spinlock (locked via CAS) used when resizing and/or creating Cells.
*/
// cell数组是否存在竞争
transient volatile int cellsBusy;
longAccumulate方法
/**
* Handles cases of updates involving initialization, resizing,
* creating new Cells, and/or contention. See above for
* explanation. This method suffers the usual non-modularity
* problems of optimistic retry code, relying on rechecked sets of
* reads.
*
* @param x the value
* @param fn the update function, or null for add (this convention
* avoids the need for an extra field or function in LongAdder).
* @param wasUncontended false if CAS failed before call
*/
final void longAccumulate(long x, LongBinaryOperator fn,
boolean wasUncontended) {
//获取当前线程的threadLocalRandomProbe值作为hash值,如果当前线程的threadLocalRandomProbe为0，
// 说明当前线程是第一次进入该方法，则强制设置线程的
//threadLocalRandomProbe为ThreadLocalRandom类的成员静态私有变量probeGenerator的值，后面会详细将hash值的生成;
//另外需要注意，如果threadLocalRandomProbe=0，代表新的线程开始参与cell争用的情况
//1.当前线程之前还没有参与过cells争用（也许cells数组还没初始化，进到当前方法来就是为了初始化cells数组后争用的）,
//是第一次执行base的cas累加操作失败；
//2.或者是在执行add方法时，对cells某个位置的Cell的cas操作第一次失败，则将wasUncontended设置为false，
//那么这里会将其重新置为true；第一次执行操作失败；
//凡是参与了cell争用操作的线程threadLocalRandomProbe都不为0；
int h;
if ((h = getProbe()) == 0) {
//强制初始化
ThreadLocalRandom.current(); // force initialization
h = getProbe();
wasUncontended = true;
}
//cas冲突标志，表示当前线程hash到的Cells数组的位置，做cas累加操作时与其它线程发生了冲突，cas失败；
//collide=true代表有冲突，collide=false代表无冲突
boolean collide = false; // True if last slot nonempty
//Spin lock + collide标志
for (;;) {
Cell[] as; Cell a; int n; long v;
//这个主干if有三个分支
//1.主分支一：处理cells数组已经正常初始化了的情况（这个if分支处理add方法的四个条件中的3和4）
//2.主分支二：处理cells数组没有初始化或者长度为0的情况；（这个分支处理add方法的四个条件中的1和2）
//3.主分支三：处理如果cell数组没有初始化，并且其它线程正在执行对cells数组初始化的操作，及cellbusy=1；
//则尝试将累加值通过cas累加到base上
//先看主分支一
if ((as = cells) != null && (n = as.length) > 0) {
//内部小分支一：这个是处理add方法内部if分支的条件3：如果被hash到的位置为null，说明没有线程在这个位置设置过值，没有竞争，
//可以直接使用，则用x值作为初始值创建一个新的Cell对象，对cells数组使用cellsBusy加锁
，然后将这个Cell对象放到cells[m%cells.length]位置上(这里的add方法都是代表LongAdder里面的add方法的判断)
if ((a = as[(n - 1) & h]) == null) {
//cellsBusy == 0 代表当前没有线程cells数组做修改
if (cellsBusy == 0) { // Try to attach new Cell
Cell r = new Cell(x); // Optimistically create
//如果cellsBusy=0无锁，则通过cas将cellsBusy设置为1加锁
if (cellsBusy == 0 && casCellsBusy()) {
boolean created = false;
try { // Recheck under lock
Cell[] rs; int m, j;
//再次检查cells数组不为null，且长度不为空，且hash到的位置的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)
break;
//如果created为false，说明上面指定的cells数组的位置cells[m%cells.length]已经有其它线程设置了cell了，继续执行循环。
continue; // Slot is now non-empty
}
}
//如果执行的当前行，代表cellsBusy=1，有线程正在更改cells数组，代表产生了冲突，将collide设置为false
collide = false;
}
//内部小分支二：如果add方法中条件4的通过cas设置cells[m%cells.length]位置的Cell对象中的value值设置为v+x失败,说明已经发生竞争，将
//wasUncontended设置为true，跳出内部的if判断，最后重新计算一个新的probe，然后重新执行循环;
else if (!wasUncontended) // CAS already known to fail
//设置未竞争标志位true，继续执行，后面会算一个新的probe值，然后重新执行循环。
wasUncontended = true; // Continue after rehash
//内部小分支三：新的争用线程参与争用的情况：处理刚进入当前方法时threadLocalRandomProbe=0的情况，也就是当前线程第一次参与cell争用的cas失败，这
//里会尝试将x值加到cells[m%cells.length]的value ，如果成功直接退出
//我觉得这里并不是threadLocalRandomProbe=0的情况，因为一开始就已经初始化了，怎么会等于0呢，应该是存在大量竞争的情况下发生的
else if (a.cas(v = a.value, ((fn == null) ? v + x :
fn.applyAsLong(v, x))))
break;
//内部小分支四：分支3处理新的线程争用执行失败了，这时如果cells数组的长度已经到了最大值（大于等于cup数量），或者是当前cells已经做了扩容，则将
collide设置为false，后面重新计算prob的值
else if (n >= NCPU || cells != as)
collide = false; // At max size or stale
//内部小分支五：如果发生了冲突collide=false，则设置其为true；会在最后重新计算hash值后，进入下一次for循环
else if (!collide)
//设置冲突标志，表示发生了冲突，需要再次生成hash，重试。 如果下次重试任然走到了改分支此时collide=true，!collide条件不成立，则走后一个分支
collide = true;
//内部小分支六：扩容cells数组，新参与cell争用的线程两次均失败，且符合扩容条件，会执行该分支
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
}
//为当前线程重新计算hash值
h = advanceProbe(h);
}
//分支二
else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
//初始化标志
boolean init = false;
try { // Initialize table
if (cells == as) {
//初始化cells数组，初始容量为2,并将x值通过hash&1，放到0个或第1个位置上
Cell[] rs = new Cell[2];
rs[h & 1] = new Cell(x);
cells = rs;
//初始化标志
init = true;
}
} finally {
cellsBusy = 0;
}
//初始化成功退出循环
if (init)
break;
}
//分支三
//如果以上操作都失败了，则尝试将值累加到base上；也就是说，只有在cells数组初始化的时候才会累加到base上面
else if (casBase(v = base, ((fn == null) ? v + x :
fn.applyAsLong(v, x))))
break; // Fall back on using base
}
}
只看上面的代码以及解释可能比较生涩，下面是流程图：
有关hash的生成
Hash是LongAdder定位当前线程将值累加到cells的哪个位置上，所以hash值的计算很重要。
追一下代码可以看到，这里使用到了Thread中的一个属性threadLocalRandomProbe。
/** Probe hash value; nonzero if threadLocalRandomSeed initialized */
@sun.misc.Contended("tlr")
int threadLocalRandomProbe;
threadLocalRandomProbe的初始化
线程对LongAdder的累加操作，在没有进入longAccumulate方法前，threadLocalRandomProbe一直都是0，当发生争用后才会进入longAccumulate方法中，进入该方法第一件事就是判断threadLocalRandomProbe是否为0，如果为0，则将其设置为0x9e3779b9。
final void longAccumulate(long x, LongBinaryOperator fn,
boolean wasUncontended) {
int h;
if ((h = getProbe()) == 0) {
//强制初始化
ThreadLocalRandom.current(); // force initialization
h = getProbe();
wasUncontended = true;
}
进入ThreadLocalRandom.current()
/**
* Returns the current thread's {@code ThreadLocalRandom}.
*
* @return the current thread's {@code ThreadLocalRandom}
*/
public static ThreadLocalRandom current() {
if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
//初始化
localInit();
return instance;
}
/**
* Initialize Thread fields for the current thread. Called only
* when Thread.threadLocalRandomProbe is zero, indicating that a
* thread local seed value needs to be generated. Note that even
* though the initialization is purely thread-local, we need to
* rely on (static) atomic generators to initialize the values.
*/
static final void localInit() {
int p = probeGenerator.addAndGet(PROBE_INCREMENT);
int probe = (p == 0) ? 1 : p; // skip 0
long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
Thread t = Thread.currentThread();
UNSAFE.putLong(t, SEED, seed);
UNSAFE.putInt(t, PROBE, probe);
}
/**
* The increment for generating probe values
*/
private static final int PROBE_INCREMENT = 0x9e3779b9;
probeGenerator 是static 类型的AtomicInteger类，每执行一次localInit()方法，都会将probeGenerator 累加一次0x9e3779b9这个值；，0x9e3779b9这个数字的得来是 2^32 除以一个常数，这个常数就是传说中的黄金比例 1.6180339887；然后将当前线程的threadLocalRandomProbe设置为probeGenerator 的值，如果probeGenerator 为0，这取1；
threadLocalRandomProbe重新生成
/**
* Pseudo-randomly advances and records the given probe value for the
* given thread.
* Duplicated from ThreadLocalRandom because of packaging restrictions.
*/
static final int advanceProbe(int probe) {
probe ^= probe << 13; // xorshift
probe ^= probe >>> 17;
probe ^= probe << 5;
UNSAFE.putInt(Thread.currentThread(), PROBE, probe);
return probe;
}