深入理解CAS与ABA问题-CSDN博客

文章目录

CAS
- 缺点
- ABA 问题

CAS

CAS: compare and swap，比较并交换。

先来看如下代码，原子类的写操作是先比较在设置。当且仅当对象偏移量V上的值和预期值A相等时，才会用更新值B更新V内存上的值，否则不执行更新。但是无论是否更新了V内存上的值，最终都会返回V内存上的旧值。

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(4);
        System.out.println(atomicInteger.compareAndSet(4,6) +" , current: "+ atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(4,10) + " ,current: "+atomicInteger.get());
    }
}

Atomic 的底层实现是 UnSafe 类。
在这里插入图片描述

UnSafe 是 CAS 的核心类。由于Java 方法无法直接访问底层 ,需要通过本地(native)方法来访问。UnSafe 可以直接操作特定额定的内存数据。UnSafe 类在于 sun.misc 包中，其内部方法操作可以像 C 指针一样直接操作内存，因为Java 中 CAS 操作的借助于依赖于 UnSafe 类的方法。

UnSafe类中所有的方法都是native修饰的,也就是说UnSafe类中的方法都是直接调用操作底层资源执行响应的任务

在这里插入图片描述
2. 变量 ValueOffset, 是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的。
3. 变量 value 由 volatile 修饰,保证了多线程之间的可见性。

UnSafe.getAndAddInt

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

    return var5;
}

假设线程A和线程B两个线程同时执行 getAndAddInt 操作(分别在不同的CPU上):
1. AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3。根据JMM模型，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。
2. 线程A通过getIntVolatile(var1,var2) 拿到value值3，这是线程A被挂起。
3.线程B也通过getIntVolatile(var1,var2) 拿到value值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存中的值也是3 成功修改内存的值为4 线程B打完收工 一切OK。
4. 这是线程A恢复，执行compareAndSwapInt方法比较,发现自己手里的数值和内存中的数字4不一致,说明该值已经被其他线程抢先一步修改了,那A线程修改失败,只能重新来一遍了.
5. 线程A重新获取value值，因为变量value是volatile修饰，所以其他线程对他的修改，线程A总是能够看到，线程A继续执compareAndSwapInt方法进行比较替换,直到成功。

缺点

循环比较开销大；
由于 UnSafe.getAndAddInt 有一个 while 循环来进行比较。如果 CAS 失败，那么循环一直存在，导致 CPU 的开销较大。
只能保证一个共享变量的原子性。如果对多个共享变量进行操作，需要使用锁操作。
导致 ABA 问题。

ABA 问题

如果主内存的共享变量值当前为 A，线程 a，b 拷贝共享变量。这是线程 a，线程 b 的共享变量值为 A，线程 b 更新共享变量值为 B，写入主内存。然后线程 b 再次拷贝共享变量，将共享变量值更新为 A，写入到主内存中。此时线程 a 才开始运行，但是线程 a 只会对比共享变量是否相等。其实主内存中的共享变量已经经历了 A -> B -> A 的变化了。

乐观锁考虑了利用版本号的方式来进行变量的锁定。因此解决 ABA 问题，也可以考虑增加一个时间戳对比验证处理。

public class ABADemo {
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(10);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);

    public static void main(String[] args) {
        new Thread(() ->{
           atomicReference.compareAndSet(10,11);
           atomicReference.compareAndSet(11,10);
        },"t1").start();

        new Thread(() ->{
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() +"\t"+ atomicReference.compareAndSet(10,2019)+"\t"+atomicReference.get());
        },"t2").start();

        System.out.println("=================ABA 解决======================");

        new Thread(() ->{
            System.out.println(Thread.currentThread().getName() +"\t"+"传入"+"\t"+ atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() +"\t"+"第一次"+"\t"+ atomicStampedReference.getStamp() + "\t" + atomicStampedReference.getReference());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() +"\t"+"第二次"+"\t"+ atomicStampedReference.getStamp() + "\t" + atomicStampedReference.getReference());
        },"t3").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"\t第1次版本号："+atomicStampedReference.getStamp());

            boolean result = atomicStampedReference.compareAndSet(100,2019,/*atomicStampedReference.getStamp()*/1,atomicStampedReference.getStamp()+1);

            System.out.println(Thread.currentThread().getName()+"\t修改成功否： "+result+"\t当前最新实际版本号："+atomicStampedReference.getStamp() + "\t" + atomicStampedReference.getReference());

        },"t4").start();
    }
}