深入理解CAS(整理自尚硅谷阳哥版本)

CAS你知道吗？

1. 比较并替换

2. CAS底层原理？如果知道，谈谈你对Unsafe的理解

   1. atomicInteger.getAndIncrement();

   2. Unsafe

   3. CAS是什么

      1. unsafe.getAndAddInt

      2. 底层汇编

      3. 简单版小总结

3. CAS缺点

/**
1. CAS是什么？==> compareAndSet
    比较并交换
*/
public class CASDemo{
    public static void main(String[] args){
        AtomicInteger atomicInteger = new AtomicInteger(5);
        //main do things ......
        
        System.out.println(atomicInteger.compareAndSet(5, 2019)+"\t current data："+atomicInteger.get());//true 2019
        System.out.println(atomicInteger.compareAndSet(5, 2019)+"\t current data："+atomicInteger.get());//false 2019
        atomicInteger.getAndIncrement();
    }
}

unsafe源码截图

Unsafe：是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native)方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。 注意：Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务

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

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

CAS的全称为Compare-And-Swap，它是一条CPU并发原语。 它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

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

cas源码图

 

 

假设线程A和线程B两个两个线程同时执行getAndAddInt操作(分别跑在不同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)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK

4. 这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其他线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了

5. 线程A重新获取value值，因为变量value被volatile修饰，所以其他线程对它的修改，线程A总是能看到，线程A继续执行compareAndSwapInt进行比较并替换，直到成功。

底层汇编(了解)

Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于unsafe.cpp中

简单版小总结：

CAS(compareAndSwap)，比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，否则继续比较直到主内存的工作内存中的值一致为止。

CAS应用：CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

CAS缺点：

1. 循环时间长开销很大：我们可以看到getAndAddInt方法执行时，有个do while，如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能给CPU带来很大的开销。

2. 只能保证一个共享变量的原子操作：当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是，多于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

3. 引出来ABA问题？？？

3、原子类AtomicInteger的ABA谈谈？原子更新引用知道的吗？

CAS --> UnSafe --> CAS底层思想 --> ABA --> 原子引用更新 --> 如何规避ABA问题

ABA：狸猫换太子

ABA问题怎么产生的？

CAS会导致"ABA问题"，CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差内会导致数据的变化。比如说一个线程one从内存位置V取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。

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

解决ABA问题 —— 理解原子引用 + 新增一种机制，那就是修改版本号(类似时间戳)

@Getter
@ToString
@AllArgsConstructor
class User{
    String userName;
    int age;
}
​
public class AtomicReferenceDemo{
    public static void main(String[] args){
        User z3 = new User("z3", 22);
        User li4 = new User("li4", 25);
        
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(z3);
        System.out.println(automicReference.compareAndSet(z3, li4)+"\t"+atomicReference.get().toString());//true li4
        System.out.println(automicReference.compareAndSet(z3, li4)+"\t"+atomicReference.get().toString());//false li4
    }
}
public class ABADemo{//ABA问题的解决  AtomicStampedReference
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 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(() -> {
            //暂停1秒钟t2线程，保证上面的t1线程完成了一次ABA操作
            try{
                TimeUnit.SECONDS.sleep(1);
               }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 2019)+"\t"+atomicReference);//true 2019
        },"t2").start();
        try{//暂停一会儿线程
                TimeUnit.SECONDS.sleep(2);
               }catch(InterruptedException e){
                e.printStackTrace();
            }
        System.out.println("==以下是ABA问题的解决==");
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t 第一次版本号"+atomicStampedReference.getStamp());
                try{//暂停1秒钟t3线程
                TimeUnit.SECONDS.sleep(1);
               }catch(InterruptedException e){
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStampt()+1);
            System.out.println(Thread.currentThread().getName()+"\t 第二次版本号"+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStampt()+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)
                try{//暂停3秒钟t4线程，保证上面的t3线程完成了一次ABA操作
                TimeUnit.SECONDS.sleep(3);
               }catch(InterruptedException e){
                e.printStackTrace();
            }
            boolean res = atomicStampedReference.compareAndSet(100, 2019,stamp,stamp+1);
            System.out.println(Thread.currentThread().getName()+"\t 修改成功与否："+res+"\t 当前最新实际版本号："+atomicStampedReference.getStamp());
            System.out.println(Thread.currentThread().getName()+"\t 当前实际最新值："+atomicStampedReference.getReference());
        },"t4").start();
    }
}