Java CAS是什么，它的底层原理？

前言

对于CAS部分学习，予以记录！

一、CAS是什么

CAS全称为Compare-And-Swap比较并交换，它是一条CPU并发原语。

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。

原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

二、CAS底层原理

CAS底层原理是通过 Unsafe类（Native方法） + CAS思想（自旋锁） 实现的

1、UnSafe类（Native方法）

UnSafe类是CAS的核心类，由于Java方法无法直接访问底层系统，则需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。

Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。

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

查看Unsafe类路径：
JDK8：\jdk8u381\jre\lib\rt.jar\sun\misc\Unsafe.class
JDK17：\jdk17008\lib\src.zip\jdk.unsupported\sun\misc\Unsafe.java

变量VALUE表示该变量值在内存中的偏移地址，因为Unsafe就是根据当前对象与其内存偏移地址获取数据的

2、CAS思想（自旋锁）

public static void main(String[] args) {
    AtomicInteger atomicInteger = new AtomicInteger(5);
    System.out.println(atomicInteger);
	// 它的功能是判断内存某个位置的值是否为预期值，如果是则返回true且将其更改为新的值，这个过程是原子的。
    System.out.println(atomicInteger.compareAndSet(5, 2019));
    System.out.println(atomicInteger.compareAndSet(2019, 6));
	// 自增并返回当前的atomicInteger值
    atomicInteger.getAndIncrement();
}

类似i++，对AtomicInteger.getAndIncrement()进行源码分析：

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

实际调用Unsafe类中的getAndAddInt()方法

进入Unsafe类，getIntVolavtile()通过o与offset获取在主内存中的值，weakCompareAndSetInt()比较并交换
该对象当前的值与v比较（自旋锁）：
如果相同，说明在此期间其他线程没有更新这个值，更新该对象当前值为v + delta，并返回true，
如果不同，说明在此期间其他线程更新了这个值，继续从主内存中取值再比较，直到更新完成。

o当前对象，offset该对象值的引用地址，expected通过o与offset找出的主内存中真实的值，x变动后的值

底层汇编语言：

小总结：

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

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

3、为什么使用CAS，不用synchronized？

CAS：保证了一致性，又兼顾了并发性
synchronized：只保证了一致性

4、CAS缺点

循环时间长开销很大

只能保证一个共享变量的原子操作

引出ABA问题

5、ABA问题，原子引用更新？

AtomicInteger：CAS --> Unsafe --> CAS底层原理 --> ABA问题 --> 原子引用更新 --> 如何规避ABA问题

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

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

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

原子引用，AtomicReference <T>

解决方案：带版本号（时间戳）的原子引用， AtomicStampedReference<T>

public static void testAtomicReference() {
     AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<Integer>(100, 1);

     System.out.println("=======以下是ABA问题的产生与解决=========");
     new Thread(() -> {
         int stamp = atomicStampedReference.getStamp();
         System.out.println(Thread.currentThread().getName() + "\t当前值：" + atomicStampedReference.getReference()
                 + "\t第1次版本号：" + stamp);
         // 暂停1s t3线程,保证t4线程取到与t3相同的版本号
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }

         atomicStampedReference.compareAndSet(100, 101,
                 atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
         System.out.println(Thread.currentThread().getName() + "\t当前值：" + atomicStampedReference.getReference()
                 + "\t第2次版本号：" + atomicStampedReference.getStamp());

         atomicStampedReference.compareAndSet(101, 100,
                 atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
         System.out.println(Thread.currentThread().getName() + "\t当前值：" + atomicStampedReference.getReference()
                 + "\t第3次版本号：" + atomicStampedReference.getStamp());

     }, "t3").start();

     new Thread(() -> {
         int stamp = atomicStampedReference.getStamp();
         System.out.println(Thread.currentThread().getName() + "\t当前值：" + atomicStampedReference.getReference()
                 + "\t第1次版本号：" + stamp);
         // 暂停3s t4线程,保证t3线程完成一次ABA操作
         try {
             TimeUnit.SECONDS.sleep(3);
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }

         boolean res = atomicStampedReference.compareAndSet(100, 2023,
                 stamp, stamp + 1);
         System.out.println(Thread.currentThread().getName() + "\t修改成功否：" + res);
         System.out.println(Thread.currentThread().getName() + "\t当前实际最新值："
                 + atomicStampedReference.getReference() + "\t当前实际最新版本号："
                 + atomicStampedReference.getStamp());
     }, "t4").start();
}