前言
CAS的全称是Compare-And-Swap，它是CPU并发原语
原语属于操作系统用于范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中 不允许被中断（保证原子性）
- 它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的，也就是说CAS是线程安全的。
代码使用
public class Test {
public static void main(String[] args) {
// 创建一个原子类，初始化为5
AtomicInteger atomicInteger = new AtomicInteger(5);
// 调用CAS方法，试图更新为2020，这里有两个参数，5表示期望值，第二个是我们要更新的值
atomicInteger.compareAndSet(5, 2020);
System.out.println("第一次调用CAS方法，数值为：" + atomicInteger);
// 然后再次使用一个方法，将值改成1024
atomicInteger.compareAndSet(5, 1024);
System.out.println("第二次调用CAS方法，数值为：" + atomicInteger);
}
}上面代码的执行结果为
这是因为我们执行第一个的时候，期望值和原本值是满足的，因此修改成功，但是第二次后，主内存的值已经修改成了2020，不满足期望值，因此写入失败。
CAS底层原理（对Unsafe的理解）
CAS我们围绕着AtomicInteger类来了解，首先先看看atomicInteger.getAndIncrement()方法的源码（实现n++的方法）
从这里能够看到，底层又调用了一个unsafe类的getAndAddInt方法
1、unsafe类
- Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于
sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存。 - Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。
- 为什么Atomic修饰的包装类，能够保证原子性，依靠的就是底层的unsafe类
2、变量valueOffset
getAndAddInt方法中，valueOffset表示该变量在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。
内存偏移量就像是c的指针，我不知道你，但是我知道你的坐标地址，我就能操作你
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
/*
this（当前对象），valueOffset（内存偏移量，也就是内存地址）
从这里我们能够看到，通过valueOffset，直接通过内存地址，获取到值，然后进行加1的操作
*/3、变量value用volatile修饰
保证了多线程之间的内存可见性。能使得CAS自旋中，可以及时知道内存的值有没有改变。
getAndAddInt方法的源码如下图：
var5就是线程从主内存中拷贝到工作内存的值。那么CAS操作的时候，需要比较工作内存中的值，和主内存中的值进行比较。假设执行 compareAndSwapInt返回false，那么就一直执行 while方法，直到期望的值和真实值一样。
- var1：AtomicInteger对象本身
- var2：该对象值的引用地址
- var4：需要变动的数量
var5：用var1和var2找到的内存中的真实值
- 用该对象当前的值与var5比较
- 如果相同，更新var5 + var4 并返回true
- 如果不同，继续取值然后再比较，直到更新完成
这就是CAS的实现机制了！！！
- 为什么AtomicInteger用CAS而不是用synchronized？
synchronized上锁减少了并发性，而CAS思想没有上锁，而是用do while循环反复用CAS比较，直到比较成功为止，这样即保证了一致性，又提高了并发性。
总结
CAS（CompareAndSwap）
比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，否则继续比较直到主内存和工作内存中的值一致为止。
CAS应用
CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B。
当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
CAS缺点
CAS不加锁，保证一次性，但是需要多次比较。
- 循环时间长，开销大（因为执行的是do while，如果比较不成功一直在循环，最差的情况，就是某个线程一直取到的值和预期值都不一样，这样就会无限循环）
只能保证一个共享变量的原子操作
- 当对一个共享变量执行操作时，我们可以通过循环CAS的方式来保证原子操作
- 但是对于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候只能用锁来保证原子性
- ABA问题？
前言：
从AtomicInteger引出下面的问题
CAS -> Unsafe -> CAS底层思想 -> ABA -> 原子引用更新 -> 如何规避ABA问题
ABA问题
一句话概括就是：狸猫换太子。
CAS只管开头和结尾，也就是头和尾是一样，那就修改成功，中间的这个过程，可能会被人修改过。尽管CAS操作成功，但是不代表这个过程是没问题的。
原子引用
原子引用其实和原子包装类是差不多的概念，就是将一个java类用原子引用类进行包装起来，那么这个类就具备了原子性。
public class User {
String name;
int age;
public User(String name, int age) {
this.age = age;
this.name = name;
}
//getter，setter方法 + toString方法
public static void main(String[] args) {
User u1 = new User("yuanqi", 18);
User u2 = new User("xiaoen", 19);
// 创建原子引用包装类
AtomicReference atomicReference = new AtomicReference<>();
// 设置现在主物理内存的共享变量为u1
atomicReference.set(u1);
// CAS，如果现在主物理内存的值为u1，那么交换为u2
atomicReference.compareAndSet(u1, u2);
// CAS，现在主物理内存的值已经被修改成u2了，因此交换失败
atomicReference.compareAndSet(u1, u2);
}
} 基于原子引用的ABA问题
public static void main(String[] args) {
// 创建原子引用包装类。类型为Integer，初始值100
AtomicReference atomicReference = new AtomicReference<>(100);
new Thread(() -> {
// 把100改为101，再改为100，也就是ABA问题
atomicReference.compareAndSet(100, 101);
atomicReference.compareAndSet(101, 100);
}, "线程A").start();
new Thread(() -> {
// 睡眠1s，保证A线程完成ABA操作。
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 测试已经狸猫换天子的100，能否被改变
atomicReference.compareAndSet(100, 666);
System.out.println("atomicReference的值为：" + atomicReference);
}, "线程B").start();
} 我们发现，它能够成功的修改，这就是ABA问题。
解决ABA问题
AtomicStampedReference类
新增一种机制，也就是修改版本号，类似于时间戳的概念
AtomicMarkableReference类
它不是维护一个版本号，而是维护一个boolean类型的标记，用法没有AtomicStampedReference灵活。因此也只是在特定的场景下使用。