java并发包中的原子操作类，这些类都是基于非阻塞算法CAS实现的。
4.1原子变量操作类
AtomicInteger/AtomicLong/AtomicBoolean等原子操作类
AtomicLong类：
public class AtomicLong extends Number implements java.io.Serializable {
// 基于硬件的原子操作类
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 存放value的偏移地址
private static final long valueOffset;
//判断jvm是否支持Long类型无锁CAS
static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
private static native boolean VMSupportsCS8();
// 初始化value字段的偏移量
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicLong.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
} // 存放具体的值
private volatile long value;
.........
}
虽然该类提供了原子操作（虽然是无阻塞的CAS操作，相对于阻塞算法提升了很火），但是在高并发情况下，会竞争更新同一个原子变量，仍然会有效率问题。
导致问题的原因也就是CAS操作：
public final long getAndAddLong(Object paramObject , long paramLongl , long paramLong2)
long l ;
do {
1 = getLongvolatile(paramObject , paramLongl) ;
// .compareAndSwapLong比较交换操作，该方法就是CAS的核心方法，但是该方法在高并发情况下，会竞争更新原子变量，最终只有一个线程更新成功，其他线程会循环多次CAS操作，浪费了cpu资源，降低了效率
) while (！compareAndSwapLong(param0bject , paramLongl , 1, 1 + paramLong2) );
return l ;
}compareAndSwapLong：paramObject操作对象，paramLong1 value的偏移量，第三个参数为except表示当前是否是该值，最后一个参数就是要修改成的值
jdk8新增的原子操作类LongAdder
为了解决高并发情况下多线程对一个共享变量的CAS争夺失败后进行自旋而造成的降低并发性能的问题，LongAdder在内部维护了一个cell元素（一个动态的cell数组）来分担对单个变量进行争夺的开销，也就是将对一个变量的争夺分配到对多个变量的争夺上。
LongAdder结构：继承Striped64
Striped64类,Cell类上有一个Contented注解，作用是避免伪共享问题
// 一个内部类，LongAdder就是通过Cell对象来提高性能，降低自选的CAS操作
@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类，基于硬件的原子操作类
private static final sun.misc.Unsafe UNSAFE;
// value在Cell对象内存地址中的偏移量
private static final long valueOffset;
// 静态代码块 初始化Unsafe类，和偏移量valueOfset
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> ak = Cell.class;
valueOffset = UNSAFE.objectFieldOffset
(ak.getDeclaredField("value"));
} catch (Exception e) {
throw new Error(e);
}
}
}
/** Number of CPUS, to place bound on table size */
static final int NCPU = Runtime.getRuntime().availableProcessors();
// cell数组，每一个线程会争夺一个cell对象，cell数组变相的降低了争夺一个变量的性能问题
transient volatile Cell[] cells;
// LongAdder的真实值就是base+cell[0]...+cell[n]
transient volatile long base;
// 为了实现自旋锁，状态值只有0和1
transient volatile int cellsBusy;
LongAdder重点方法add():
当内部increment或decrement自增或自减操作是，内部调用的就是add方法，当cell数组为空时，默认走的就是casBase方法（此时和AtomicLong操作相同，即都是在base的基础上进行累加或累减操作的）。
进入第3行if判断的情况：
1：cells不为空，会进入if
假如cells不为空进入的if判断，则第5行结果为false，第6行会判断Thread对象中的threadLocalRandomProbe的值是否存在，不存在，则直接调用longAccumulate方法，存在的话，会进一步判断a.cas操作是否成功，不成功则调用longAccumulate方法，成功则代表add方法累加成功
2：casBase操作失败，会进入if
如果cells为空，casBase方法操作失败，则进入if判断中，且第5行为true，则直接调用longAccumulate方法
1 public void add(long x) {
2 Cell[] as; long b, v; int m; Cell a;
3 if ((as = cells) != null || !casBase(b = base, b + x)) {
4 boolean uncontended = true;
5 if (as == null || (m = as.length - 1) < 0 ||
6 (a = as[getProbe() & m]) == null ||
7 !(uncontended = a.cas(v = a.value, v + x)))
8 longAccumulate(x, null, uncontended);
9 }
10 }
11
12 /**
13 * Equivalent to {@code add(1)}.
14 */
15 public void increment() {
16 add(1L);
17 }
18
19 /**
20 * Equivalent to {@code add(-1)}.
21 */
22 public void decrement() {
23 add(-1L);
24 }
longAccumulate方法是进行cells数组初始化和扩容的地方
final void longAccumulate(long x, LongBinaryOperator fn,
boolean wasUncontended) {
int h;
// 初始化probe，也就是Thread类中的threadlocalsRandomProbe变量
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;
// 这里和上边add方法的两种情况对应，一种是cells不为null，一种是未null，当前if为cells不为null的时候会进入
if ((as = cells) != null && (n = as.length) > 0) { // as[(n-1) & h] 里边的索引和上一步add方法中的相同，都是通过probe的值 并上 cells数组的长度减1， 这一块就是获取线程应该访问的Cell对象（相当于AtomicLong对象中的共享变量）
if ((a = as[(n - 1) & h]) == null) {
if (cellsBusy == 0) { // Try to attach new Cell 当前索引处无Cell对象，并且没有线程在执行CAS操作，则会新建一个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，并且能够将cellsBusy自增为1时，也就是能够加锁时，进入判断内
else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
boolean init = false;
try { // Initialize table
if (cells == as) { // 默认初始化Cell数组大小为2
Cell[] rs = new Cell[2];
rs[h & 1] = new Cell(x);
cells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
// 以上条件都不满足，如果指定了operation方法，则使用operation进行操作，没有的话，则进行累加操作（这块是针对自定义operation的）
else if (casBase(v = base, ((fn == null) ? v + x :
fn.applyAsLong(v, x))))
break; // Fall back on using base
}
}
LongAccumulator类：LongAdder是LongAccumulator的一个特例，后者提供了更加强大的功能，可以让用户自定义累加规则
public LongAccumulator(LongBinaryOperator accumulatorFunction,
long identity) {
this.function = accumulatorFunction;
base = this.identity = identity;
}
// java8中的函数式接口可以自定义操作规则，累加、累乘等操作
@FunctionalInterface
public interface LongBinaryOperator {
/**
* Applies this operator to the given operands.
*
* @param left the first operand
* @param right the second operand
* @return the operator result
*/
long applyAsLong(long left, long right);
}