CAS

CAS（Compare And Swap）比较并交换。

它的功能是判断内存中某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子性的。CAS有三个操作数，内存地址V，旧的预期值A，要修改的新值。当且仅当预期值A和内存地址V所在值相同时，将内存地址V所在值的修改为B，否则什么都不做。

CAS并发语体现在java中就是sun.misc.Unsafe类中的各种方法。调用Unsafe类中的CAS方法，JVM会帮我们实现CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行的过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

1，Unsafe

Unsafe是CAS的核心类，由于java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法可以向C的指针一样直接操作内存，因为java中CAS操作的执行依赖于Unsafe类的方法。

注意：Unsafe类中的方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应的任务。

2，变量valueOffset，表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址来获取数据的。

//atomicInteger.getAndIncrement(); 
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
 }

//下面是Unsafe类下的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;
}

3，变量value用volatile修饰，保证了多线程之间的内存可见性。

假设线程A和线程B两个线程同时执行getAndAddInt操作（分别跑在不同CPU上）

1. AtomicInteger里面的value原始值假设为3，即主内存中AtoInteger的value为3，根据JMM，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。
2. 线程A通过getIntVolatile(var1,var2)拿到value值3，这时线程A被挂起。
3. 线程B通过getIntVolatile(var1,var2)拿到value值3，此时刚好线程没有被挂起并执行compareAndSwapInt方法比较，内存值也为3，成功修改内存值为4，线程B结束。
4. 这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其他线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了。
5. 线程A重新获取value值，因为变量value被volatile修饰，所以其他线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt方法进行比较替换，直到成功。

CAS的缺点：

1. 循环时间长开销很大。如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。
2. 只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以使用锁来保证原子性。
3. ABA问题。

ABA问题

CAS算法实现一个重要前提需要取出内存中某个时刻的数据并在当下时刻比较并替换，那么在这个时间差内就会导致数据的变化。

比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，然后线程two又将V位置的数据变成A。这时候线程one进行CAS操作发现内存中仍然是A，然后线程A操作成功。

尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。

ABA问题可以使用AtomicStampedReference来解决，通过引用和戳（相当于版本号）双重验证。

public class ABADemo {

    static Integer one=new Integer(100);
    static Integer two=new Integer(200);
    static Integer three=new Integer(300);

    static AtomicReference<Integer> atomicReference=new AtomicReference<>(100);
    static AtomicStampedReference atomicStampedReference=new AtomicStampedReference(one,1);


    public static void main(String[] args) {
        System.out.println("----------------ABA问题产生----------------");

        new Thread(()->{
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();

        new Thread(()->{
            try{
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 102)+"\t "+atomicReference.get());
        },"t2").start();

        try{
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("----------------ABA问题解决----------------");
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+" 第一次版本是\t:"+stamp);


            //让线程t4获取到最开始的值和版本
            try{
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //t3重现ABA现象
            atomicStampedReference.compareAndSet(one, two, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName()+" 第二次版本是\t:"+atomicStampedReference.getStamp()+" "+atomicStampedReference.getReference());
            atomicStampedReference.compareAndSet(two, one, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName()+" 第三次版本是\t:"+atomicStampedReference.getStamp());
        },"t3").start();

        new Thread(()->{
            //获取最开始的版本
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+" 第一次版本是\t:"+stamp);

            //让线程t3重现ABA现象
            try{
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //查看AtomicStampedReference是否解决ABA问题
            boolean result = atomicStampedReference.compareAndSet(one, three, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName()+" 是否修改成功:"+result+"\t 当前值"+atomicStampedReference.getReference());
            System.out.println(Thread.currentThread().getName()+"当前版本:"+atomicStampedReference.getStamp());

        },"t4").start();

    }

}

结果显示：