CAS底层原理

前言

• CAS的全称是Compare-And-Swap（比较与替换），它是CPU并发原语，对应到CPU指令为cmpxchg
• 它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的，也就是说CAS是线程安全的。
• CAS有三个操作数：当前值A、内存值V、要修改的新值B。

  假设 当前值A 与 内存值V 相等，那就将内存值V 改成B。假设不相等，要么就重试，要么就放弃更新。

代码使用

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表示在内存中<font color="red">编译地址</font>

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缺点

CAS不加锁，保证一次性，但是需要多次比较。

1. 循环时间长，开销大（因为执行的是do while，如果比较不成功就一直在循环）
2. 只能保证一个共享变量的原子操作。对于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候只能用锁来保证原子性

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<User> atomicReference = new AtomicReference<>();

        // 设置现在主物理内存的共享变量为u1
        atomicReference.set(u1);

        // CAS，如果现在主物理内存的值为u1，那么交换为u2
        atomicReference.compareAndSet(u1, u2);

        // CAS，现在主物理内存的值已经被修改成u2了，因此交换失败
        atomicReference.compareAndSet(u1, u2);
    }
}

• 原子引用 也存在 ABA的问题。

解决ABA问题

AtomicStampedReference类

新增一种机制，也就是修改版本号，类似于时间戳的概念。比对的就是 内存值+版本 是否一致。

AtomicMarkableReference类

它不是维护一个版本号，而是维护一个boolean类型的标记，用法没有AtomicStampedReference灵活。因此也只是在特定的场景下使用。