16.ABA问题

ABA问题

因为CAS操作的原子性能高，在JUC中广泛被应用，但是如果使用的不合理，CAS操作就会存在ABA问题！

1.什么是ABA问题？

ABA问题是指在并发编程中，由于CAS（比较并交换）操作的特性，可能出现的一种问题。CAS是一种乐观锁机制，用于实现多线程环境下的原子操作。它通常包含三个参数：期望值、更新值和当前值。CAS操作会比较当前值和期望值，如果相等，则将当前值更新为新值，否则不进行任何操作。

CAS操作的局限性导致了ABA问题的出现。具体而言，ABA问题通常在以下情况下出现：

1. 并发场景下的共享变量修改：多个线程同时对一个共享变量进行修改和操作。
2. CAS操作的原子性：CAS操作只能检查共享变量当前的值是否和预期值相等，并在相等时才进行更新操作。
3. 中间值的变化：如果在CAS操作执行过程中，共享变量的值经历了从预期值A到其他值B，再回到A的变化，那么CAS操作可能会错误地认为共享变量的值没有发生变化。

举例来说，假设一个共享变量的初始值为A，在某个线程执行CAS操作之前，另一个线程将该变量的值从A修改为B，然后再将其修改回A。如果执行CAS操作的线程只关注共享变量的当前值是否和预期值相等，而不考虑中间值的变化，那么CAS操作会错误地认为共享变量的值没有发生变化，导致出现问题。

因此，ABA问题的产生是由于CAS操作只关注共享变量的当前值，而忽略了中间值的变化。这种问题可能会导致并发控制失效，数据不一致等后果，因此需要针对性地设计解决方案来解决ABA问题。

下面通过一个案例，来了解一下ABA问题

假设现在有一个栈，该栈是采用单链表进行实现的，元素的插入和删除都发生在单链表的头部。

假设，线程1 和线程2 是两在堆栈上并发操作的线程，其中线程1计划从head位置通过CAS操作进行元素“B”的弹出操作

此时线程1刚好启动CAS执行，但是还没有开始执行，线程2抢在线程1前面弹出了元素“B”，并且压入了一个新的元素“C”，再压入了“B”,此时通过CAS操作后 head位置还是“B”

这个时候切换到线程1执行，通过CAS发现线程2的位置还是 “B”操作成功！将“B”弹出并压入新的元素“B”,尽管线程1操作成功，但是这样会存在一个很大问题

1.已知 栈顶的元素为 B，这个时候线程A知道 B.next = NULL , 希望使用CAS操作，CAS(B,A)将栈顶的元素替换成A，从而将B元素从堆栈中弹出

2.但是由于线程1 和线程2是并发执行的，CPU时间片不巧分配给了线程2，线程2弹出了B，A元素，然后压入了C，B，最终线程又将head的位置变成了B

3.接下来线程1从新获得CPU时间片，执行CAS(B,A)，操作成功，将B弹出压入了但是此时，链表就断开了，C元素不在存储于堆栈中了，被丢掉了！

这就是ABA引发的不正常的状态

2.ABA问题解决方案

很多乐观锁的实现版本都是使用版本号（version）的方式来解决ABA问题。每次对共享变量进行修改时，版本号都会相应地递增。这样，在执行CAS操作时，除了比较共享变量的值外，还会比较版本号，从而更精确地判断共享变量是否发生了变化。

2.1.使用AtomicStampedReference解决ABA问题

AtomicStampedReference 是 Java 并发包中提供的一个工具类，用于解决 CAS 操作中的 ABA 问题。与 AtomicReference 不同，AtomicStampedReference 在每个引用值的基础上都附加了一个整型的标记（stamp），用来记录引用值的版本号。这个版本号在每次更新引用值时会自动增加，因此可以用来检测引用值是否发生过变化，从而避免 ABA 问题。

具体来说，AtomicStampedReference 的主要特性包括：

1. 原子性操作： AtomicStampedReference 提供了一系列原子性的操作方法，包括 compareAndSet、get、set 等，确保多线程环境下的安全访问。
2. 版本号标记： 每个引用值都与一个整型的版本号相关联，用于标记引用值的版本信息。版本号会在每次更新引用值时自动增加，从而在CAS操作中额外检测引用值的变化。
3. 解决ABA问题： 通过版本号标记，AtomicStampedReference 可以检测到引用值的变化过程，即使引用值发生了从 A 到 B 再到 A 的变化，只要版本号不同，CAS操作就会失败，从而避免了ABA问题。

使用 AtomicStampedReference 解决ABA问题的一般步骤如下：

1. 初始化 AtomicStampedReference，并指定初始的引用值和版本号。
2. 在每次对共享变量进行修改时，使用 AtomicStampedReference 的原子性方法，同时更新引用值和版本号。
3. 在CAS操作中，除了比较共享变量的值外，还要比较版本号是否与预期版本号相同。只有在共享变量的值和版本号都与预期值相同时，才执行更新操作。

通过这种方式，AtomicStampedReference 可以有效地解决CAS操作中的ABA问题，提高了并发环境下的安全性和可靠性。

    @Test
    @DisplayName("使用AtomicStampedReference解决ABA问题")
    public void testAtomicStampedReference() throws InterruptedException {
        // 初始化 AtomicStampedReference，初始值为初始对象和版本号为0
        AtomicStampedReference<String> atomicStampedRef = new AtomicStampedReference<>("初始值", 0);

        // 创建两个线程，分别进行CAS操作
        Thread thread1 = new Thread(() -> {
            // 获取当前版本号
            int stamp = atomicStampedRef.getStamp();
            // 获取当前引用值
            String value = atomicStampedRef.getReference();
            log.info("线程1开始执行，当前版本号：{}，当前值：{}", stamp, value);
            // 模拟线程1执行耗时操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 尝试更新引用值和版本号
            boolean success = atomicStampedRef.compareAndSet(value, "新值1", stamp, stamp + 1);
            if (success) {
                log.info("线程1更新成功，新版本号：{}", stamp + 1);
            } else {
                log.error("线程1更新失败，当前值已经被其他线程修改");
            }
        });

        Thread thread2 = new Thread(() -> {
            // 获取当前版本号
            int stamp = atomicStampedRef.getStamp();
            // 获取当前引用值
            String value = atomicStampedRef.getReference();
            log.info("线程2开始执行，当前版本号：{}，当前值：{}", stamp, value);
            // 尝试更新引用值和版本号
            boolean success = atomicStampedRef.compareAndSet(value, "新值2", stamp, stamp + 1);
            if (success) {
                log.info("线程2更新成功，新版本号：{}", stamp + 1);
            } else {
                log.error("线程2更新失败，当前值已经被其他线程修改");
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();

        // 等待线程执行完成
        thread1.join();
        thread2.join();

        // 输出最终结果
        log.info("最终值：{}", atomicStampedRef.getReference());
    }

2.2.使用AtomicMarkableReference解决ABA问题

AtomicMarkableReference 是 AtomicStampedReference 简化版本，他不关心修改过几次，他只关心有没有被修改过。

1. AtomicMarkableReference 是 Java 中提供的一种原子引用类，用于解决 CAS 操作中的 ABA 问题。与 AtomicStampedReference 类似，AtomicMarkableReference 也使用了版本号（mark）的方式来确保 CAS 操作的正确性。

   特性：

   1. AtomicMarkableReference 内部包含了一个引用对象和一个标记（mark），它们共同构成了一个原子更新单元。
   2. 标记（mark）是一个布尔值，用于辅助 CAS 操作，标记位的变化表明了引用对象的状态变化。
   3. 提供了 compareAndSet 方法来进行原子更新，确保引用对象和标记的更新是原子性的。
   4. 使用 AtomicMarkableReference 可以避免 CAS 操作中的 ABA 问题，从而更安全地进行并发编程。

   使用过程：

   1. 创建 AtomicMarkableReference 对象时，需要传入初始引用对象和初始标记。
   2. 使用 get 方法可以获取当前的引用对象和标记。
   3. 使用 compareAndSet 方法进行原子更新，需要传入旧的引用对象、新的引用对象、旧的标记和新的标记，只有在旧的引用对象和标记与当前值相同时，才会更新为新的值。
   4. 提供了一种线程安全的机制，可以避免 CAS 操作中的 ABA 问题，确保并发操作的安全性。

    @Test
    @DisplayName("测试使用AtomicMarkableReference解决ABA问题")
    public void testAtomicMarkableReference() throws InterruptedException {
        // 初始化 AtomicMarkableReference，初始值为初始对象和标记为false
        AtomicMarkableReference<String> atomicMarkableRef = new AtomicMarkableReference<>("初始值", false);

        // 创建两个线程，分别进行CAS操作
        Thread thread1 = new Thread(() -> {
            // 获取当前标记
            boolean[] markHolder = new boolean[1];
            // 获取当前引用值
            String value = atomicMarkableRef.get(markHolder);
            log.info("线程1开始执行，当前标记：{}，当前值：{}", markHolder[0], value);
            // 模拟线程1执行耗时操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 尝试更新引用值和标记
            boolean success = atomicMarkableRef.compareAndSet(value, "新值1", markHolder[0], true);
            if (success) {
                log.info("线程1更新成功，新标记：{}", true);
            } else {
                log.error("线程1更新失败，当前值已经被其他线程修改");
            }
        });

        Thread thread2 = new Thread(() -> {
            // 获取当前标记
            boolean[] markHolder = new boolean[1];
            // 获取当前引用值
            String value = atomicMarkableRef.get(markHolder);
            log.info("线程2开始执行，当前标记：{}，当前值：{}", markHolder[0], value);
            // 尝试更新引用值和标记
            boolean success = atomicMarkableRef.compareAndSet(value, "新值2", markHolder[0], true);
            if (success) {
                log.info("线程2更新成功，新标记：{}", true);
            } else {
                log.error("线程2更新失败，当前值已经被其他线程修改");
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();

        // 等待线程执行完成
        thread1.join();
        thread2.join();

        // 输出最终结果
        log.info("最终值：{}", atomicMarkableRef.getReference());
    }