前言

  • 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不加锁，保障一次性，然而须要屡次比拟。

  1. 循环工夫长，开销大（因为执行的是do while，如果比拟不胜利始终在循环，最差的状况，就是某个线程始终取到的值和预期值都不一样，这样就会有限循环）

  2. 只能保障一个共享变量的原子操作

    • 当对一个共享变量执行操作时，咱们能够通过循环CAS的形式来保障原子操作
    • 然而对于多个共享变量操作时，循环CAS就无奈保障操作的原子性，这个时候只能用锁来保障原子性
  3. 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<User> 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<Integer> 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灵便。因而也只是在特定的场景下应用。