深入理解CAS

什么是CAS

CompareAndSet  比较交换 ：比较当前内存和主内存中的值，如果达到预期，就进行交换，如果没有达到，就一直循环。

缺点：1.由于底层是自旋锁，循环较为耗时 2.一次只能保证一个共享变量的原子性 3.存在ABA问题

在Java的原子类中存在CAS方法，其方法底层则是调用Unsafe类中的CAS方法。

什么是Unsafe类：它是Java用来修改内存中变量的一个后门类，其底层都是C++对于内存变量的直接修改方法。

以AtomicInteger的加法为例，可以看到它的底层就是使用的自旋锁的CAS方法，我们来解释一下这个CAS方法的原理

var1是我们传入进来对象的地址，var2则是指向当前对象地址的值，当我们的var2的值达到var5这个期望值后，我们则会对于var2进行加var4计算 也就是var2的值加1

如果var2没有达到var5期望值时，则会在自旋锁中不断循环。这里就时直接对于内存变量的计算，效率很高。

CAS的ABA问题 ABA（狸猫换太子）

当我们两个不同线程a,b来对于一个共享变量A进行CAS操作时，可能存在这样的情况

我们的a线程在获取A准备计算时，线程b要快一步，对A进行了1置换为3，然后又3置换为1 再返回给了主内存

那这个时候，我们a线程拿到的A变量已经不是原有的变量A了，这就是ABA问题。

package com.gupao.juc.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS compareAndSet:比较并交换
    public static void main(String args[]){
        AtomicInteger atomicInteger = new AtomicInteger(200);

        //对于我们平时写的SQL：乐观锁
        //期望，更新
        //public final boolean compareAndSet(int expect,int update)
        //如果我期望的值达到了，那么就更新，否则就不更新 CAS 是CPU的并发原语
        //=============捣乱的线程================//
        System.out.println(atomicInteger.compareAndSet(200, 201));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(201, 200));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(200, 666));
        System.out.println(atomicInteger.get());
    }
}

那么我们要如何来解决ABA问题呢

原子引用

我们需要使用原子引用（相当于乐观锁，对于我们的CAS操作加上版本号来进行判断）

需要用到类：AtomicStampReference

package com.gupao.juc.cas;


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

public class CASDemo2 {
    public static void main(String[] args) {
        //构建AtomicStampedReference对象，版本号为1
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"版本号===>"+atomicStampedReference.getStamp());
            System.out.println(Thread.currentThread().getName()+"运行结果====>"+atomicStampedReference.compareAndSet(1,
                    2,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));//进行一次CAS操作，版本号为2
            //运行完后，打印版本号
            System.out.println(Thread.currentThread().getName()+"版本号====>"+atomicStampedReference.getStamp());

            System.out.println(Thread.currentThread().getName()+"运行结果====>"+atomicStampedReference.compareAndSet(2,
                    1,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));//再进行一次CAS操作，版本号为3
            //运行完后，打印版本号
            System.out.println(Thread.currentThread().getName()+"版本号====>"+atomicStampedReference.getStamp());
        },"a").start();
        
        
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"运行结果====>"+atomicStampedReference.compareAndSet(1, 5,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));//另一个线程也做一次CAS操作
            System.out.println(Thread.currentThread().getName()+"版本号===>"+atomicStampedReference.getStamp());
        },"b").start();

    }
}

我们此时可以看到，对于每一次的CAS操作，我们都有一次版本号的对应，当我们每成功操作一次CAS后，版本号会+1，否则不会。