CAS底层原理

CAS

CAS：compare-And-Swap，比较与替换，是一种cpu原语。 用真实值和期望值进行比较，如果相等，则替换并返回true；不相等返回false；
其底层是用Unsafe类中的方法实现的。Unsafe是java rt.jar中sun.misc中的一个原生类。该类下的大部分方法是用native修饰的。所以
java可以间接的操作计算机底层的源码。由于原语是计算机最底层的语言，是不可以分割的，故而保证了原子性。CAS对应的原语是compxchg。

	 CAS的实现是通过Unsafe中的getAndAdd方法实现的，该方法有三个参数，当前对象，内存地址，和需要操作的值。通过do-while循环，先根据
	 getIntVolatile方法获取主内存的值，然后和期望值进行比较，相同则替换并退出循环，不同则继续获取最新值再次比较。

源码：

/**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

上述是AtomicInteger中的comperAndSet的源码。
其有两个参数：

• expect(期望值)
• update(所要修改的值)

此方法的作用是，判断当前值是否等于期望值，如果和期望值相等，则把当前值替换为update值，并返回true；不等，返回false。

实例

package cas;

import java.util.concurrent.atomic.AtomicInteger;

/*
*  CAS(comperAndSet,比较与替换)
* */
public class CASDemo {

    public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger(5);

        //当前值为5，与expect值比较，相等，则把当前值替换成2021
        System.out.println(atomicInteger.compareAndSet(5, 2021)+"\t current data: "+atomicInteger.get());
        //经过上述代码替换后，当前值为2021，此时与expect值进行比较，不相等，返回false，值还是2021
        System.out.println(atomicInteger.compareAndSet(5, 1000)+"\t current data: "+atomicInteger.get());

    }

}

底层原理

CAS的核心是Unsafe类和自旋锁。

atomicInteger.getAndIncrement();

此方法是进行递增操作，和i++一样，不过它是原子性的。下面就来看看它的源码，为什么此方法是原子性。

/**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
     //this当前对象，valueOffset：内存偏移量(内存地址)
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

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

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

2.变量valueOffset，表示该变量值在内存中的偏移地址，所以Unsafe会根据偏移地址获取数据。

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

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

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

unsafe.getAndAddInt源码

//var1就是传过来的对象，var2是内存偏移量，var4就是对应getAndIncrement的1
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
        	//根据此对象和内存地址，获取对应的值var5
            var5 = this.getIntVolatile(var1, var2);
           //用该对象当前的值与var5比较，如果相同，更新var5+var4的值并返回true；如果不同，继续取值然后比较，直至更新完成；
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

可以看到，getAndAddInt方法所用到的都是Unsafe当中的native方法。

public native int getIntVolatile(Object var1, long var2);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

执行步骤

假设线程A和线程B两个线程同时执行getAndAddInt操作。

• AtomicInteger里面的value原始值是3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一份值为3的副本分别到各自的工作内存中。
• 线程A通过getIntVolatile(var1,var2)获取value值3，这是线程A被挂起。
• 线程B也通过getIntVolatile(var1,var2)获取值3，并执行compareAndSwapInt()方法，比较内存值也为3，成功修改值4。
• 这是线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值3和内存中的值4不一致，说明该值已经被修改过了，那么再次进入循环执行getIntVolatile方法，获取最新值4。
• 因为变量被volatile修饰，所以其他线程对它的修改，线程A总是能看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。

CAS缺点

• 在高并发下，有可能需要多次的比较，会给CPU带来很大的开销。
• 只能保证一个共享变量的操作。
• ABA问题。