CAS操作

CAS操作

CAS是compareAndSwap的缩写，它是一条CPU并发原语。由于CAS是一种系统原语，属于系统用语范畴，由若干条指令组成，用于完成某个功能的一个过程，原语的执行必须是连续的，不允许被中断，所以CAS是一条CPU的原子指令，不会造成数据不一致。在上一篇文章重我们用到AtomicInteger原子类，它有一个方法public final boolean compareAndSet(int expect, int update)，包含两个参数，一个为期望值，一个为更新值。

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(5, 2019));
    }
}

atomicInteger的初始值为5，调用compareAndSet方法意思是如果期望值为5，即期望内存中的值为5，也就是没有其它线程动过，则将它的值设置为2019。

CAS底层原理

CAS主要依靠java jdk的sun.misc包的UnSafe类进行一些底层系统的操作。

    public final int getAndAddInt(Object var1, long offset, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, offset);
        } while(!this.compareAndSwapInt(var1, offset, var5, var5 + var4));
        return var5;
    }

首先拿到当前原子对象的值var5，然后进入compareAndSwapInt方法，拿出内存偏移量为offset的值，如果是var5，说明没人动过，那么就加var4;否则，自旋直到成功。

CAS缺点

• 如果CAS自旋锁一直不成功，就跳不出循环，会消耗CPU资源
• 只能保证一个共享变量的原子问题
• ABA问题

ABA问题

举个例子，假设有个共享变量var1 = 5，线程B对其进行compareAndSet操作，期望值填5，但是在此期间线程A将var1的值改成了10，然后又改成了5，然而线程B没有发现，虽然最后更新成功，但是对于关注var1变化过程的问题，这是一种问题。这就是ABA问题。

public class ABADemo {
    static AtomicReference atomicReference = new AtomicReference<>(5);
    public static void main(String[] args) {
        //该线程完成一次ABA操作
        new Thread(() -> {
            atomicReference.compareAndSet(5,10);
            atomicReference.compareAndSet(10,5);
        }).start();
        
        new Thread(() -> {
            //等待上面线程完成一次ABA操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicReference.compareAndSet(5,10);
            System.out.println("atomicReference的值为" + atomicReference.get());
        }).start();
    }
}

• 解决：使用带版本号的原子引用AtomicStampedReference<>，这样数值不单单是数值，而是附带有一个版本号的。

public class ABADemo {
    static AtomicStampedReference atomicStampedReference = new AtomicStampedReference<>(5,1);
    public static void main(String[] args) {
        //该线程完成一次ABA操作
        new Thread(() -> {
            System.out.println("线程1拿到初始版本号：" + atomicStampedReference.getStamp());
            //等待线程2拿到版本号
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(5,10, atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
            System.out.println("线程1修改值为：" + atomicStampedReference.getReference() + " " + "版本号：" + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(10,5, atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
            System.out.println("线程1修改值为：" + atomicStampedReference.getReference() + " " + "版本号：" + atomicStampedReference.getStamp());

        }, "线程1").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println("线程2拿到初始版本号：" + stamp);
            //等待上面线程完成一次ABA操作
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean success = atomicStampedReference.compareAndSet(5, 10, stamp, stamp + 1);
            System.out.println("线程2是否修改成功：" + success);
        }).start();
    }
}
运行结果：
线程1拿到初始版本号：1
线程2拿到初始版本号：1
线程1修改值为：10 版本号：2
线程1修改值为：5 版本号：3
线程2是否修改成功：false

由代码可见，线程1完成了一次ABA操作，数值从5 -> 10 -> 5，然而最后的5不再是开始时的5，因此，线程B拿开始时的版本号去更新值是无法成功的。