一，什么是CAS

CAS就是compareAndSet的缩写，他会比较内存中的值是否是期望的值，如果期望的值就执行操作，否则会由于它的底层是自旋锁而等待操作的执行。

public static void main(String[] args)  {
       AtomicInteger atomicInteger = new AtomicInteger(2021);
        //CAS就是compareAndSet的缩写，期望的值为2021，如果满足就将数据更新为2022，否则不更新
       atomicInteger.compareAndSet(2021,2022);
    }

优点：操作的原子性

缺点：

自旋锁的循环会耗时

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

有ABA问题

 

二，ABA问题

什么是ABA：一个线程将数据A修改为B后再修改为A，另外一个线程发觉不了，因为它拿到数据为A认为没有被修改过，就执行A修改为B

例子：

　　线程1：想要将2021修改为2022，如果期望的值为2021就可以修改成功

　　线程2：为一个捣乱的线程，它先将2021修改为2022，然后线程会对拿到的值进行其它一系列的非法操作，

　　最终将2022修改为2021，给线程1一个错觉执行成功

代码示例：

static AtomicInteger atomicInteger = new AtomicInteger(2021);
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->
        {
            //捣乱的线程
            atomicInteger.compareAndSet(2021,2022);
            System.out.println(atomicInteger.get());
            System.out.println(Thread.currentThread().getName()+"拿着修改后的值进行非法操作");
            atomicInteger.compareAndSet(2022,2021);
            System.out.println(atomicInteger.get());
        }).start();
        TimeUnit.SECONDS.sleep(2);
        //实际执行的线程
        atomicInteger.compareAndSet(2021,2022);
        System.out.println(atomicInteger.get());
    }

如何解决ABA问题？

使用原子引用来解决

//通过版本号来防止修改（乐观锁）
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->
        {
            System.out.println("线程1进入时的版本号："+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean updateSuccess1 = atomicStampedReference.compareAndSet(100, 101,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(atomicStampedReference.getStamp());
            System.out.println("线程1修改1："+updateSuccess1);
            boolean updateSuccess2 = atomicStampedReference.compareAndSet(101,100,
                    atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(atomicStampedReference.getStamp());
            System.out.println("线程1修改2："+updateSuccess2);
        }).start();
        new Thread(()->
        {
            System.out.println("线程2进入时的版本号："+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //实际执行的线程
            boolean updateSuccess3 = atomicStampedReference.compareAndSet(100,101,
                    atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(atomicStampedReference.getStamp());
            System.out.println("线程2修改："+updateSuccess3);
        }).start();
    }