一、案例

CAS是Java中Unsafe类里面的一个方法，它的全称是叫CompareAndSwap比较并交换的一个意思，它的主要功能是能够去保证在多线程的环境下对于共享变量修改的一个原子性。

例如，比如说像这样一个场景，有一个成员变量state，默认值是0，其中定义了一个方法叫doSomething()，这个方法的逻辑是先判断state是否为0，如果为0就修改成1。

这个逻辑在单线程的情况下看起来没有任何问题，但是在多线程的环境下会存在原子性的问题，因为这里是一个典型的Read和Write的一个操作，一般情况下我们会在doSomething()这个方法去加一个synchronized的同步锁来解决这样的一个原子性的问题，但是加同步锁一定会带来性能上的损耗，所以对于这一类的场景，我们可以使用CAS机制来进行优化。

优化后的代码：

在doSomething()这个方法中，调用了unSafe类中的compareAndSwapInt()方法来达到同样的目的。这个方法有四个参数，分别是当前对象实例，成员变量state在内存地址中的一个偏移量，预期值0和期望更改之后的值1。

CAS机制会比较state内存地址偏移量对应的值和传入的预期值0是否相等，如果相等就直接修改内存地址中state的值等于1，否则返回false，表示修改失败，而这个过程它是一个原子的，不会存在任何线程安全的问题。（比较线程的期望值与物理内存的真实值）

CompareAndSwap是一个native方法，实际上它最终还是会面临同样的问题，就是先从内存地址中读取state值，然后再去比较，最后再去修改，这过程不管是在什么层面去实现都会存在原子性问题，所以在CompareAndSwap的底层实现里面，如果是在多核的CPU环境下，会增加一个lock指令来对缓存或者总线去加锁，从而去保证比较并替换这两个操作的原子性。

CAS主要是应用在一些并发场景里面，比较典型的使用场景有两个：

第一个是J.U.C里面的Atomic包里面的原子性实现，比如AtomicInteger、tomicLong；

第二个是实现多线程对共享资源竞争的互斥性质，比如AQS、ConcurrentHashMap、ConcurrentLinkedQueue等。

二、Unsafe类

1、Unsafe类

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

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

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

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

三、CAS

CAS全称是叫CompareAndSwap比较并交换，它是一条CPU并发原语。

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

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

四、CAS缺点

循环时间长、开销大

getAndAddInt方法执行时，有个do while，如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

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

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，

但是，当对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。

引出来ABA问题

五、ABA问题

1、ABA问题

CAS会导致“ABA问题”。

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

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

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

2、AtomicReference原子引用

@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(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
    }
}

3、ABA问题解决

AtomicStampedReference版本号原子引用

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABADemo {
    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(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 2019) + "\t 当前值：" + atomicReference.get());
        }, "t2").start();

        System.out.println("=================以下是ABA问题的解决=====================");
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);

            // t3线程暂停1s
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t第2次版本号：" + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t第3次版本号：" + atomicStampedReference.getStamp());
        }, "t3").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);

            // t4线程暂停3s，保证t3线程完成ABA
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t修改是否成功：" + result + "\t当前最新版本号：" + atomicStampedReference.getStamp());

            System.out.println(Thread.currentThread().getName() + "\t当前实际最新值：" + atomicStampedReference.getReference());
        }, "t4").start();
    }
}