CAS 与 ABA问题

本文通过学习：周阳老师-尚硅谷Java大厂面试题第二季总结的CAS和ABA相关的笔记

一、CAS

1、CAS定义

CAS = Compare-And-Swap，它是CPU并发原语。

比较当前工作内存中的值和主物理内存中的值，如果相同则执行规定操作，否者继续比较直到主内存和工作内存的值一致为止。

3个操作数，内存值V，旧的预期值A，要修改的更新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否者什么都不做

2、CAS底层原理(unsafe类 + 变量valueOffset + 变量value用volatile修饰)

atomicInteger.getAndIncrement()

实际是调用了一个unsafe类的getAndAddInt方法

unsafe

变量valueOffset

变量value用volatile修饰

usafe

Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（Native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定的内存数据。Unsafe类存在sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中的CAS操作的执行依赖于Unsafe类的方法。注意Unsafe类的所有方法都是native修饰的，也就是说unsafe类中的方法都直接调用操作系统底层资源执行相应的任务。

为什么Atomic修饰的包装类？->能够保证原子性，依靠的就是底层的unsafe类。

valueOffset

该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。

通过valueOffset，直接通过内存地址，获取到值，然后进行加1的操作。

value用volatile修饰

volatile保证了多线程之间的内存可见性。

3、CAS优缺点

优点

CAS不加锁，在并发量不高时会提高效率。

缺点

循环时间长，开销大。因为执行的是do while，如果比较不成功一直在循环，最差的情况，就是某个线程一直取到的值和预期值都不一样，这样就会无限循环。

只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以通过循环CAS的方式来保证原子操作；但是对于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候只能用锁来保证原子性。

ABA问题。

4、synchronized与CAS区别

synchronized

(悲观锁)

CPU 悲观锁机制，即线程获得的是独占锁。独占锁就意味着其他线程只能依靠阻塞来等待线程释放锁。而在 CPU 转换线程阻塞时会引起线程上下文切换，当有很多线程竞争锁的时候，会引起 CPU 频繁的上下文切换导致效率很低。尽管 Java1.6 为 synchronized 做了优化，增加了从偏向锁到轻量级锁再到重量级锁的过度，但是在最终转变为重量级锁之后，性能仍然较低。

CAS

(乐观锁)

乐观锁，它不会阻塞任何线程，所以在效率上，它会比 synchronized 要高。所谓乐观锁就是：每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。

二、ABA问题及解决

原子引用

结果：

true 2019

原子引用计数(解决ABA问题)

结果：

t3 第一次版本号1

t4 第一次版本号1

t3 第一次版本号2

t3 第一次版本号3

t4 修改成功否：false 当前最新实际版本号：3

t4 当前实际最新值100

public class ABADemo {
    //普通的原子引用包装类
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);

    public static void main(String[] args) {
        new Thread(() -> {
            // 把100 改成 101 然后在改成100，也就是ABA
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }, "t1").start();

        new Thread(() -> {
            try {
                // 睡眠一秒，保证t1线程，完成了ABA操作
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 2019) 
                        + "\t" + atomicReference.get());

        }, "t2").start();
    }
}
//true    2019

public class ABADemo {
    // 传递两个值，一个是初始值，一个是初始版本号
    static AtomicStampedReference<Integer> atomicStampedReference 
                    = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            threadName = Thread.currentThread().getName();
            int stamp1 = atomicStampedReference.getStamp();//获取版本号
            System.out.println(threadName + "\t 第一次版本号" + stamp1);
        
            // 传入4个值，期望值，更新值，期望版本号，更新版本号
            int stamp2 = atomicStampedReference.getStamp();
            atomicStampedReference.compareAndSet(100, 101, stamp2, stamp2+1);
            System.out.println(threadName + "\t 第二次版本号" + stamp2);

            int stamp3 = atomicStampedReference.getStamp();
            atomicStampedReference.compareAndSet(101, 100, stamp3, stamp3+1);
            System.out.println(threadName + "\t 第三次版本号" + stamp3);

        }, "t3").start();

        new Thread(() -> {
            threadName  = Thread.currentThread().getName();
            int stamp1 = atomicStampedReference.getStamp();
            System.out.println(threadName + "\t 第一次版本号" + stamp1);

            // 暂停3秒钟，保证t3线程也进行一次ABA问题
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp+1);
            int stamp2 = atomicStampedReference.getStamp();
            System.out.println(threadName + "\t 修改成功否：" + result + "\t 当前最新实际版本号：" + stamp2);
            System.out.println(threadName + "\t 当前实际最新值" + atomicStampedReference.getReference());
        }, "t4").start();
    }
}
/**
t3    第一次版本号1
t4    第一次版本号1
t3    第一次版本号2
t3    第一次版本号3
t4    修改成功否：false 当前最新实际版本号：3
t4    当前实际最新值100
*/