CAS机制与ABA问题以及解决方案

龙域、白泽

已于 2022-07-06 13:59:44 修改

阅读量943

点赞数 4

分类专栏： JUC 文章标签： java

于 2022-03-26 10:07:46 首次发布

本文链接：https://blog.csdn.net/m0_56750901/article/details/123751099

版权

JUC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

CAS：比较并交换（CompareAndSwap）

CAS属于乐观锁的实现，Synchronized属于悲观锁的实现

原子类实现原子操作的原理就是CAS机制

CAS机制保证了原子操作，也增加了耗时

CAS机制中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B

更新一个变量的时候，只有当变量的预期值A（工作内存中的副本的值）和内存地址V当中的实际值（主内存中的值）相同时，则内存地址V对应的值修改为B，否则重新获取内存地址V当中的实际值一直比较直到相等

线程A要把变量的值从10 修改为 11，此时，内存地址V当中的实际值 = 10，旧的预期值 = 10，要修改的新值 = 11
线程B抢先把10修改成了12
此时A线程的预期值为10，实际值为12，不相等，执行失败
线程A再次获取预期值 = 11，没有其他线程修改变量的值
预期值与实际值相同执行成功，变量的值从12变成11

这个重新尝试的过程被称为自旋

CAS的缺点：

CPU开销较大：在并发量比较高的情况下，如果许多线程反复尝试更新某一个变量，却又一直更新不成功，循环往复，会给CPU带来很大的压力
不能保证代码块的原子性，只是一个变量的原子性操作。比如需要保证3个变量共同进行原子性的更新，就不得不使用Synchronized
ABA问题

ABA问题

狸猫换太子

CAS算法实现一个重要前提需要取出内存中某时刻的数据并与主内存数据比较，那个这个时间差内，数据可能会变化，比如A和B线程都从主内存中取出count1，B线程对数据操作，count1中的数据改变成了count2，然后B线程又把数据变回count1，刷回主内存，这时线程A进行CAS操作发现主内存中的仍是count1，然后线程A操作成功。

尽管线程A的CAS操作成功，但不代表这个操作过程是没有问题的

本质：ABA问题的根本在于CAS在修改变量的时候，无法记录变量的状态，比如修改的次数，否修改过这个变量。这样就很容易在一个线程将A修改成B时，另一个线程又会把B修改成A，造成CAS多次执行的问题。

解决ABA

通过原子引用(AtomicReference)加标记的原子引用(AtomicStampedReference)解决ABA问题

AtomicStampedReference在CAS的基础上在主存中增加了一个标记stamp，每次有线程更新主内存中的数据就更新时间戳。当CAS进行比较的时候不仅比较值，还比较标记

private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);// 设置值为100
private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);// 设置值为100，标记为1

public static void main(String[] args) {
    System.out.println("=========以下ABA问题产生：=========");
    // 线程 t1 模拟ABA问题的产生
    new Thread(() -> {
        // 进行一次修改，将值修改为101
        atomicReference.compareAndSet(100, 101);
        // 进行第二次修改，将值修改回100
        atomicReference.compareAndSet(101, 100);
    }, "t1").start();

    new Thread(() -> {
        // 线程t2暂停1S，保证线程t1执行完成
        try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {e.printStackTrace();}
        System.out.println(atomicReference.compareAndSet(100, 102));
        System.out.println("修改成功，修改后值为："+atomicReference.get());
    }, "t2").start();


    try {TimeUnit.SECONDS.sleep(2);} catch (Exception e) {e.printStackTrace();}
    System.out.println("=========以下ABA问题解决方式：=========");

    new Thread(() -> {
        // 获取版本号
        int stamp = atomicStampedReference.getStamp();
        System.out.println("线程名称："+Thread.currentThread().getName()+"，第一次版本号："+stamp);
        try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {e.printStackTrace();}
        // 进行一次修改，将值修改为101
        atomicStampedReference.compareAndSet(100,101,stamp,stamp+1); // 参数代表的含义分别是 期望值，写入的新值，期望标记，新标记值
        stamp = atomicStampedReference.getStamp();
        System.out.println("线程名称："+Thread.currentThread().getName()+"，第二次版本号："+stamp);
        // 进行第二次修改，将值修改回100
        atomicStampedReference.compareAndSet(101,100,stamp,stamp+1);
        stamp = atomicStampedReference.getStamp();
        System.out.println("线程名称："+Thread.currentThread().getName()+"，第三次版本号："+stamp);
    }, "t3").start();

    new Thread(() -> {
        // 获取版本号
        int stamp = atomicStampedReference.getStamp();
        System.out.println("线程名称："+Thread.currentThread().getName()+"，第一次版本号："+stamp);
        // 线程t4暂停1S，保证线程t3执行完成
        try {TimeUnit.SECONDS.sleep(2);} catch (Exception e) {e.printStackTrace();}
        boolean andSet = atomicStampedReference.compareAndSet(100, 101, stamp,stamp+1);
        System.out.println("线程名称："+Thread.currentThread().getName()+"，修改结果："+andSet+"，第二次版本号:"+stamp+1+"实际版本号："+atomicStampedReference.getStamp());
        System.out.println("当前最新值："+atomicStampedReference.getReference());
    }, "t4").start();
}