iv002-CAS是什么

1.CAS是什么？

CAS的全称是 compare and swap（比较并交换），它是一条CPU并发原语。

• 它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。
• CAS并发原语体现在Java语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。就是这一种完全依赖硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPPU的原子指令，不会造成所谓的数据不一致问题。

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

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

小结：CAS 比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，否则继续比较直到主内存和工作内存中的值一致为止。
应用：CAS 有三个操作数，内存值V，旧的预期值A，要修改的更新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则说明都不做。

2.CAS底层原理

自旋+UnSafe类

3.CAS缺点

• 1.循环时间长开销很大。

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;
}

如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

• 2.只能保证一个共享变量的原子操作。
  当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以使用锁来保证原子性。
• 3.引出来ABA问题。
  CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。
  比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。
  尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。
  ABA问题解决示例代码：

public class AtomicDemo {

    public static void main(String[] args) {
        AtomicReference<Integer> atomicReference = new AtomicReference<>(100);

        System.out.println("===============ABA=================");
        new Thread(() -> {
            System.out.println(atomicReference.compareAndSet(100, 101) + "	" + Thread.currentThread().getName() + "	 atomicReference:" + atomicReference.get());

            System.out.println(atomicReference.compareAndSet(101, 100) + "	" + Thread.currentThread().getName() + "	 atomicReference:" + atomicReference.get());
        }, "t1").start();

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

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "	 atomicReference:" + atomicReference.get());

        System.out.println("===============ABA解决=================");

        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1) + "	" + atomicStampedReference.getStamp() + "	" + Thread.currentThread().getName() + "	 atomicStampedReference:" + atomicStampedReference.getReference());

            System.out.println(atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1) + "	" + atomicStampedReference.getStamp() + "	" + Thread.currentThread().getName() + "	 atomicStampedReference:" + atomicStampedReference.getReference());
        }, "t3").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(100, 2021, stamp, stamp + 1) + "	" + stamp + "	" + Thread.currentThread().getName() + "	 atomicStampedReference:" + atomicStampedReference.getReference());
        }, "t4").start();

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "	 atomicStampedReference:" + atomicStampedReference.getReference());

    }
}

运行结果：

===============ABA=================
true	t1	 atomicReference:101
true	t1	 atomicReference:100
true	t2	 atomicReference:2021
main	 atomicReference:2021
===============ABA解决=================
true	2	t3	 atomicStampedReference:101
true	3	t3	 atomicStampedReference:100
false	1	t4	 atomicStampedReference:100
main	 atomicStampedReference:100