我的jdk源码（二十四）：AtomicInteger类和CAS机制
一、概述
AtomicInteger类处于java.util.concurrent.atomic包下，与其他原子操作的类一样，底层都是采用CAS机制，调用了Unsafe类的CAS方法实现的。我们先分析一下AtomicInteger类的源码，再来分析CAS机制的种种。
二、源码分析
1. 类的声明
public class AtomicInteger extends Number implements java.io.Serializable继承了 Number， 这主要是提供方法将数值转化为 byte, double 等方便 Java 开发者使用； 实现了 Serializable， 为了网络传输等的序列化用， 编码时最好手动生成序列化 ID， 让 javac 编译器生成开销大， 而且可能造成意想不到的状况。
2. 成员变量
//序列化标识id
private static final long serialVersionUID = 6214790243416807050L;
//Unsafe类的一个实例，提供一些不安全的操作的方法用于直接操作内存，一般不会在自己的程序中使用该类
//在这里主要用到其中的objectFieldOffset、putOrderedInt、compareAndSwapInt方法
private static final Unsafe unsafe = Unsafe.getUnsafe();
//value成员属性的内存地址相对于对象内存地址的偏移量
private static final long valueOffset;
////初始化valueOffset，通过unsafe.objectFieldOffset方法获取成员属性value内存地址相对于对象内存地址的偏移量
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//int的值，volatile修饰，保证线程之间的可见性
private volatile int value;Unsafe类是一个JDK内部使用的专属类，我们自己的应用程序无法直接使用Unsafe类。通过观察源码，可以知道获得Unsafe实例的方法是调动其工厂方法getUnsafe()，源码如下：
@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}它会检查调用getUnsafe()函数的类，判断调用这的类加载器是否是系统类加载器(系统类加载器为null)，如果不是就直接抛出异常，拒绝工作，这也是为什么我们写的程序没法直接使用这个类的原因。
3. 构造函数
//int参数类型的构造函数
public AtomicInteger(int initialValue) {
value = initialValue;
}
//无参构造函数，初始值是0
public AtomicInteger() {
}4. 其他方法
/**
* 获取int值
*/
public final int get() {
return value;
}
/**
* 设为指定值
*/
public final void set(int newValue) {
value = newValue;
}
/**
* 最终设为指定值，但其它线程不能马上看到变化，会延时一会
*/
public final void lazySet(int newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue);
}
/**
* 以原子方式设置为给定值，并返回旧值
*/
public final int getAndSet(int newValue) {
//乐观锁，非阻塞同步方式，循环调用compareAndSet，也就是自旋，直到成功
for (;;) {
int current = get();
//CAS操作，期待值current与内存中的值比较，相等的话设为newValue值
//否则下个循环，调用get()获取current值，继续执行CAS操作直到成功
if (compareAndSet(current, newValue))
return current;
}
}
/**
* CAS操作，现代CPU已广泛支持，是一种原子操作；
* 简单地说，当期待值expect与valueOffset地址处的值相等时，设置为update值
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 弱比较
*/
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
//调用unsafe.getAndAddInt方法进行数值操作
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
//调用unsafe.getAndAddInt方法进行数值操作
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
//调用unsafe.getAndAddInt方法进行数值操作
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
//调用unsafe.getAndAddInt方法进行数值操作
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
//调用unsafe.getAndAddInt方法进行数值操作
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
/**
* 原子操作，自增，返回旧值
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
/**
* 原子操作，自减，返回旧值
*/
public final int getAndDecrement() {
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return current;
}
}
/**
* 原子操作，加上一个数，返回旧值
*/
public final int getAndAdd(int delta) {
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return current;
}
}
/**
* 原子操作，自增，返回新值
*/
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
/**
* 原子操作，自减，返回新值
*/
public final int decrementAndGet() {
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return next;
}
}
/**
* 原子操作，加上一个数，返回新值
*/
public final int addAndGet(int delta) {
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return next;
}
}
/**
* Returns the String representation of the current value.
* @return the String representation of the current value.
*/
public String toString() {
return Integer.toString(get());
}
public int intValue() {
return get();
}
public long longValue() {
return (long)get();
}
public float floatValue() {
return (float)get();
}
public double doubleValue() {
return (double)get();
}
}5. getAndAddInt()方法
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}第一个参数var1为给定的对象，var2为对象内的偏移量（其实就是一个字段到对象头部的偏移量，通过这个偏移量可以快速定位字段），var4表示期望值，var5表示要设置的值。如果指定的字段的值等于var4，那么就会把它设置为var5。
6. CAS机制原理
CAS全拼又叫做compareAndSwap，从名字上的意思就知道是比较交换的意思。它包含 3 个参数 CAS（V，E，N），V表示要更新变量的值，E表示预期值，N表示新值。仅当 V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做两个更新，则当前线程则什么都不做。最后，CAS 返回当前V的真实值。
7. CAS的优势
CAS是一种乐观锁，而且是一种非阻塞的轻量级的乐观锁。当一个线程想要获得锁，对方会给一个回应表示这个锁能不能获得。在资源竞争不激烈的情况下性能高，相比synchronized重量锁，synchronized会进行比较复杂的加锁，解锁和唤醒操作。
8. CAS存在的问题
(1) ABA问题
* 问题描述：CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。
* 解决办法：
a. 用CAS的一个变种DCAS，DCAS是对于每一个V增加一个引用的表示修改次数的标记符。对于每个V，如果引用修改了一次，这个计数器就加1，然后再这个变量需要更新的时候，就同时检查变量的值和计数器的值。都符合条件才可以修改V值。
b. 通过将标记与要进行CAS操作的每个值相关联，并原子地更新值和标记。也就是一旦V第一次被使用，就不会再重复使用，如有需要则分配新的V。垃圾收集器可以检查V，保证其不被循环使用，直到当前的访问操作全部结束。使用 AtomicStampedReference 来解决CAS中的ABA问题，它不再像compareAndSet方法 中只比较内存中的值也当前值是否相等，而且先比较引用是否相等，然后比较值是否相等。
c. 设置一个版本号，每次修改都会修改版本号，每次对比的时候不仅对比值，还要对比版本号来保证数据没被修改。
(2) 自旋时间长导致开销大
* 问题描述：自旋 CAS 如果长时间不成功，会给 CPU 带来非常大的执行开销。
* 解决办法：如果JVM能支持处理器提供的 pause 指令那么效率会有一定的提升，pause 指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使 CPU 不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation：内存顺序冲突一般是由伪/假共享引起，假共享是指多个 CPU 同时修改同一个缓存行的不同部分而引起其中一个CPU的操作无效，当出现这个内存顺序冲突时，CPU必须清空流水线）而引起 CPU 流水线被清空（CPU pipeline flush），从而提高 CPU 的执行效率。
三、总结
通过本篇博文，对原子包java.util.concurrent.atomic下的AtomicInteger类进行了分析，其他的类也比较类似，都是底层采用了CAS机制完成各种操作。也学习了CAS的原理和存在的问题以及解决办法。
更多精彩内容，敬请扫描下方二维码，关注我的微信公众号【Java觉浅】，获取第一时间更新哦！
