CAS详解

一、CAS概念

1.1 CAS是什么

 Compare And Swap

比较并交换

1. 如果线程的期望值跟物理内存的真实值一样，就更新值到物理内存当中，并返回true

2. 如果线程的期望值跟物理内存的真实值不一样，返回false，那么本次修改失败，那么此时需要重新获得主物理内存的新值

1.2 图解说明

主物理内存有一个共享变量值为5，有两个线程T1，T2，他们都有自己的工作内存，并且有变量的拷贝(快照5)，T1线程现在把值改为2019，然后，写回主物理内存并通知其它线程可见(加volatile)，这个过程中。T1的期望值为5，要跟主物理内存的值5进行对比，如果相同，说明没有其它线程改变，则将主物理内存的值改为2019，并返回true。这时，T2线程也将自己工作内存的值改为了1024，但是，当写回主物理内存时，发现自己的期望值(5)，与现在的主物理内存(2019)不一样了，就会写入失败，返回false，此时需要重新获得主物理内存的新值

1.3 代码示例 

/**
 * CAS是什么？ ->compare and swap
 * 比较并交换
 */
public class CASDemo {
    public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger(5);

        //模拟T1线程
        System.out.println(atomicInteger.compareAndSet(5, 2019) + "\t current data: " + atomicInteger.get());

        //模拟T2线程
        System.out.println(atomicInteger.compareAndSet(5, 1024) + "\t current data: " + atomicInteger.get());
    }
}

二、CAS底层原理

2.1 UnSafe类

2.1.1 Unsafe

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

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

2.1.2 valueOffset

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

当前对象，这个地址的值，进行加1操作

2.1.3 value

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

2.2 CAS是什么

2.2.1 深层分析

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

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

1. var1：当前对象，AtomicInteger对象本身
2. var2： 该对象值的引用地址
3. var4：需要变动的数值
4. var5：是用var1和var2找出的主内存中真实的值

用该对象当前的值与var5主物理内存的值比较

如果相同，更新var5+var4，并且返回true

如果不同，继续取值然后再比较，直到更新完成

synchronized加锁，同一时间，只能有一个线程访问，一致性得到了保障，并发性下降。CAS用的do while，没有加锁，反复的通过CAS比较，直到成功，既保证了一致性，又提高了并发性。

原子整型之所以在i++这种多线程的环境下面，不用加synchronized，就凭着底层Unsafe类也能来保证原子性，来保证线程安全，是因为Unsafe是CAS的核心类，CAS是比较并交换，Unsafe类根据内存偏移地址，来获取数据。

2.2.2 流程分析

 

假设线程A和线程B两个线程同时执行getAndAddInt操作(分别在不同CPU上)

1. AutomicInteger里面的value原始值为5，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一份值为5的value的副本分别到各自的工作内存。

2. 线程A通过getIntVolatile(var1,var2)拿到value值5，这时线程A被挂起

3.线程B也通过getIntVolatile（var1,var2)拿到value值5，此时刚好线程B没有被挂起，并执行compareAndSwapInt方法比较内存中的值也是5，成功修改内存的值为2019，线程B打完收工一切OK

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

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

2.2.3 底层汇编

2.2.4 小结

1. CAS

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

2. CAS应用

CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B。

当且仅当预期值A和内存值V相同时，将内存值V修改为B,否则什么都不做。

三、CAS缺点

3.1 多次比较循环时间长开销很大

我们可以看到getAndAddInt方法执行时，有个do while

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

3.2 只能保证一个共享变量的原子性

CAS进针对当前对象

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

3.3 引入ABA问题

两个线程T1和T2,T1完成要10s,T2完成要2s，现在主内存有一个值A，T1和T2各有一个拷贝，T2因为很快，先把值更新为B，然后，又把主内存的B更新为A，这时候，T1线程准备更新值时，与主内存值比较发现还是A，认为没有变化。但是，由于时间差的问题，这个值可能已经被其他线程改了多次，只不过最后还是改成了原来的A，这就是ABA问题。

CAS会导致“ABA问题”

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

比如说一个线程one，从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，然后

线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。

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

@Getter
@Setter
@ToString
@NoArgsConstructor
@AllArgsConstructor
class User {
    private String name;
    private int age;
}
public class AtomicReferenceDemo {

    public static void main(String[] args) {

        User a = new User("a", 22);
        User b = new User("b", 23);
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(a);
        System.out.println(atomicReference.compareAndSet(a, b) + "\t" + atomicReference.get().toString());

        System.out.println(atomicReference.compareAndSet(a, b) + "\t" + atomicReference.get().toString());
    }
}

 

3.4 总结

synchronized加锁，一致性保证，并发性下降

CAS不加锁，保证一致性，但是它如果多次比较，耗时时间长，开销大。

****，源码