CSDN个人博客:https://blog.csdn.net/wangrain1
了解了Java虚拟机，线程，锁，volatile概念之后对多线程开发算是比较熟悉了。解决线程并发产生的问题，除了锁，volatile等关键字之外，在特定的情景下为了提高代码运行的效率，为了摆脱“锁”这个独占式的编程方式之外，还有另外一个原子类的概念。
在java.util.concurrent.atomic包下有Java提供的线程安全的原子类。了解 AtomicInteger 和 CAS 机制。
1. AtomicInteger的实现
通过上一篇中volatile的自增的例子，我们知道要想实现这种自赠的效果就需要加锁，为了提高效率，这种场景下原子类型就可以胜任。
AtomicIntegerai =new AtomicInteger(1);
ai.incrementAndGet();
查看实现代码：
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
根据incrementAndGet()方法了解到AtomicInteger是对U的一个封装，U就是Unsafe类。
private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
private static final long VALUE;
static {
try {
VALUE = U.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (ReflectiveOperationException e) {
throw new Error(e);
}
}
private volatile int value;
这段代码首先获得Unsafe对象，先声明一下Unsafe是个单例，Unsafe里面基本都是native方法。
static代码块里面初始化了VALUE这个值，static修饰的类加载的时候就会被初始化，并且引用是放到 Jvm的方法区的属于类的数据。
继续VALUE是什么呢？查看U.objectFieldOffset()方法：
/**
* Gets the raw byte offset from the start of an object's memory to
* the memory used to store the indicated instance field.
*
* @param field non-null; the field in question, which must be an
* instance field
* @return the offset to the field
*/
public long objectFieldOffset(Field field) {
return field.getOffset();
}
看方法注释：从对象的内存处开始，获得原始字节偏移量，用于存储实力对象的内存。好像还是不理解～。画个图：
上几篇提到对象在内存中的分布其中有个padding对齐，就是保证一个对象的内存大小必须是8的倍数。在这里偏移量的意思就像我们 new 一个数组，数组的地址就是数组地一个元素的地址，假如数组地址是 a，第二个元素就是a+1,其中+1就是偏移量。对应的对象的一个属性的偏移量就是其对象的地址开始增加，增加的数就是这个filed的偏移量。
对于VALUE这个值我们知道了，他是AtomicInteger中的value属性对应的偏移量，就是对象地址+VALUE = value的地址
继续看代码：
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
/**
* Atomically adds the given value to the current value of a field
* or array element within the given object {@code o}
* at the given {@code offset}.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param delta the value to add
* @return the previous value
* @since 1.8
*/
// @HotSpotIntrinsicCandidate
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}
知道了offset值的意义之后
继续向下就是 v = getIntVolatile(o, offset); 这段代码，这个代码含义其实就是根据object和属性在object中的偏移地址，拿到 v（对应的共享内存中的 value 值，通过volatile控制值的可见性）。
compareAndSwapInt(o, offset, v, v + delta) 这个就是CAS(CompareAndSwap)机制 = 先拿着 v（预期的值）和 共享内存的值做比较 如果其他线程没有修改过就替换掉，否则就一直自旋判断直到成功。
如果在比较过程中不成功，也就是值被其他线程修改了，这时候CAS机制是一直循环的，这样无非也会消耗大量CPU。
2. CAS实现原子性操作的三大问题
这部分引用于：https://www.jianshu.com/p/5ee20d1128da
CAS虽然很高的解决了原子操作，但是CAS仍然存在三大问题。ABA问题、循环时间长开销大、以及只能保证一个共享变量的原子操作。
ABA问题
因为CAS需要在操作值的时候，检查值有没有发生变化，如果发生变化则更新，但是如果一个值为A，变成了B，又变成了A，那么使用CAS进行检查时就会发现它的值没有发生变化，但实际上发生变化了。ABA问题的解决思路就是使用版本号，在变量前边追加版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题。
从java1.5开始，JDK提供了AtomicStampedReference、AtomicMarkableReference来解决ABA的问题，通过compareAndSet方法检查值是否发生变化以外检查版本号知否发生变化。
循环时间长开销大
自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。
只能保证一个共享变量的原子操作
当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。
从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。
