关于CAS浅析

在我们的日常开发工作中，经常用到的JUC中的很多功能，其实这些javaAPI提供给我们的功能，本质上还是依赖了CAS思想的，下面就CAS进行分析：

CAS的核心思想

CAS本质上来说就是Compare and Swap，见文知意，也就是比较交换的意思，就这么简单。但是到底层实现上来说就有些复杂了。

乐观锁

在我们深入分析CAS的前面我们先了解一下乐观锁机制。
乐观锁（ Optimistic Locking）其实是一种思想。相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。
我们今天所进行讨论的CAS就是使用了乐观锁的思想，与之对应的就是悲观锁机制，我们常用的数据库的加锁机制就是悲观锁的实现。

CAS原理解析

CAS的核心思想非常简单，把官方文档解释过来的意识就是：
三个参数，一个当前内存值 V、旧的预期值 A、即将更新的值 B，当且仅当预期值 A 和内存值 V 相同时，将内存值修改为 B 并返回 true，否则什么都不做，并返回 false。很简单这就是CAS的核心思想。
最方便的就是我们拿我们常用的AtomicInteger进行分析：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }

    private volatile int value;
    //篇幅问题，省略不影响分析的代码

    /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

}

在上面的代码块中可以很明显的看到private volatile int value;这一小段代码是借助了volatile原语的，保证了变量在多个线程间的可见性。
上述代码中我们看到了Unsafe的使用，先是获取到了Unsafe这个类，这个类其实是jdk自带的一个类，我们打开安装包可以看到一个rt文件夹，在里面有个sun.misc包这里面就放了一些native的方法，这些是java中无法直接调用的基于C/C++的实现的，我们平时很少用得到。

valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));

观察上面的代码可知，unsafe类获取到了一个值，一开始我自己阅读的时候被这个问题绕了很久，查了很多资料才明白，这段代码的意思是通过unsafe提供的底层方法获取当前对象也就是AtomicInteger的当前实例对象的值在内存中的偏移量也即是内存的地址，也就是最准确的，利用了指针的思想。
上述代码片段的最后一部分便是使用CAS的关键，调用的是底层硬件级别的原语，我们在IDEA中的看源码是看不到的，他长得是这个样子的：
下面便是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;
}

下面就是对于这段的代码的解析，也即是本文的重点：
首先我们定义了一个名为var5的变量，var5是根据传入的当前对象也即是前面所提到的AtomicInteger的当前实例对象，在根据前面从unsafe获取的内存偏移量获取一个值，便是var5。

this.compareAndSwapInt(var1, var2, var5, var5 + var4)

对于上面便是核心：
var1：当前AtomicInteger对象；
var2：内存偏移量；
var5：上面do循环里面的获取的var5；
流程是这样的：在compareAndSwapInt方法中我们先根据var1、var2获取一个当前对象在指定内存偏移量的值，然后和前面一步获得var5进行比较相等的话则进行相加，返回Ture取反后返回False此时while条件中的条件为False，退出循环返回var5。这便是CAS的基本原理。相比较加锁的机制，这种方法可以提供较大的并发量，万事都有两面性，换取并发量高的代价就是CPU的消耗会比较大，因为While循环那里相当于是一个死循环。同时还会打出ABA的问题，关于ABA的问题有时间会专门写一篇关于ABA的，并提供常用解决方案。
对于上述提及的CompareAndSwapInt方法，其实是一个本地的native的方法，如下所示：

public final native boolean compareAndSwapInt(Object paramObject, long paramLong, 
												int paramInt1, int paramInt2);

java中并没有直接实现CAS的方法，而是通过 JNI 才能调用，其他的native方法也是如此，以为这些都是调用C/C++的实现的，查看源码：

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

这里使用的是底层汇编的原语，偏硬件的实现方法，就不做解释了。但是我们要知道这个操作是原子性的，是建立在底层硬件指令级别的操作，举个比方就好比你的BOSS来公司吃饭，谁敢插队，没人敢吧（可能不恰当，但是大致就是那个意思）。
至此CAS的浅显的解释基本就这些。
本人认知有限，如有错误请不吝赐教。