CAS是什么？

　　CAS的全称为Compare-And-Swap它是一条CPU并发原语，也就是在CPU硬件层面上来说比较并且判断是否设置新值这段操作是原子性的，不会被其他线程所打断。在JAVA并发包java.util.concurrent.atomic下底层所采用的就是利用CAS机制来避免进行并发计算时导致数据错乱问题。

atomic底层实现

java.util.concurrent.atomic下各个类主要使用UnSafe类来进行Compare-And-Swap操作。
Unsafe是Java中一个底层类，包含了很多基础的操作，比如数组操作、对象操作、内存操作、CAS操作、线程(park)操作、栅栏（Fence）操作，JUC包、一些三方框架都使用Unsafe类来保证并发安全。Unsafe类在jdk 源码的多个类中用到，这个类的提供了一些绕开JVM的更底层功能，基于它的实现可以提高效率。但是，它是一把双刃剑：正如它的名字所预示的那样，它是Unsafe的，它所分配的内存需要手动free（不被GC回收）。Unsafe类，提供了JNI某些功能的简单替代：确保高效性的同时，使事情变得更简单。
如果需要自定义原子引用则可以通过类AtomicReference通过泛型设置，本篇不做过多介绍。
接下来以AtomicInteger类为切入点来看看Atomic是如何利用Compare-And-Swap来保证并发安全。

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    //1.objectFieldOffset()方法用于获取某个字段相对Java对象的起始地址的偏移量。
    //2.下次访问将直接通过this对象与相对偏移量直接从内存访问value的值。从不经过JVM虚拟机。
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    private volatile int value;
    
    .
    .
    .
    //调用unsafe对预期值进行判断,如果判断成功则将值设置进去。
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
    //调用unsafe.getAndAddInt方法，该方法内部采用自旋锁不断compareAndSet当设置成功后才跳循环,否则不断得查询并且计算然后进行compareAndSet。
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

public final class Unsafe {
    .
    .
    .
    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
    public native int getIntVolatile(Object var1, long var2);
    //通过一个死循环不停的获取值并且计算然后比较是否能够设置否则继续如此操作。
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        //compareAndSwapInt是Unsafe类利用计算机底层实现的，该操作是具有原子性，所以不必担心并发问题。
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
        return var5;
    }
}

CAS的缺点

因为CAS并不像synchronized锁住整个方法，其他线程会处于等待锁释放状态。所以CAS的并发性会增强。但是在并发性增强的同时也会伴随着一些缺陷。

1. 循环时间长、CPU开销会增大。
2. 只能保证一个共享变量的原子操作。
3. 引出ABA问题。

ABA问题

假设有这么一个变量a其初始值为1，两个线程分别为线程A与线程B，线程A的调用周期远低于线程B。

顺序	线程A	线程B
1		a=getIntVolatile(0)
2	a=getIntVolatile(0)
3	this.compareAndSwapInt(var1, var2, a, 1)
4	a=getIntVolatile(1)
5	this.compareAndSwapInt(var1, var2, a, 0)
6		this.compareAndSwapInt(var1, var2, a, 2)

对于线程B是能够compareAndSwapInt成功的他无法感知到线程A将a变量设置为1后又设置为0的过程，线程B只关注结果，只要在执行compareAndSwapInt的时候预期值符合就能够将值设置进去。

ABA问题解决

解决ABA问题的其中思路就是引入版本号控制。对于每个compareAndSet成功的则版本号进行加1，然后每次拿着这个版本号去做期望值匹配，这样就能够避免ABA问题。所幸在java.util.concurrent.atomic包下同样有为我们提供已版本号为基础的原子引用操作类AtomicStampedReference。

//创建出AtomicStampedReference实例，参数分别为初始值和初始版本号
AtomicStampedReference<Integer> atomicStampedReference=new AtomicStampedReference(100,1);
//获取当前版本号
int stamp=atomicStampedReference.getStamp();
//执行比较并且设置参数分别为期望值,设置新值,期望版本号,设置新版本号
atomicStampedReference.compareAndSet(100,200,stamp,stamp+1)