如何解决 ABA 问题？

八股文_Java并发基础题 0 30

参考回答

ABA 问题是指在使用无锁算法（如 CAS 操作）时，一个变量从初始值 A 变为 B，又变回 A。此时，其他线程无法感知变量的中间状态变化，会错误地认为变量从未被修改过。解决 ABA 问题的常用方法是使用 版本号机制 或 原子引用+标记。

详细讲解与拓展

1. 什么是 ABA 问题？

ABA 问题的典型场景是基于 CAS（Compare-And-Swap，比较并交换）实现的算法中：

CAS 比较时只检查当前值是否与期望值相同。
如果值相同，则认为变量未被修改，直接交换新值。
但实际上，变量可能经历了其他线程的修改，从 A -> B -> A，导致结果可能不符合预期。

示例：ABA 问题场景

AtomicInteger atomicInt = new AtomicInteger(1);
boolean result = atomicInt.compareAndSet(1, 2); // 返回 true
// 假设其他线程将值从 2 改回 1
boolean result2 = atomicInt.compareAndSet(1, 3); // 错误地返回 true，认为值未被修改

在上述场景中，第二次 CAS 操作错误地认为值从未被修改，实际上变量经历了中间状态。

2. ABA 问题的解决方法

2.1 使用版本号机制

通过在变量值中增加一个版本号，保证即使变量的值重复，版本号也能唯一标识每次修改。

核心思想：
- 使用一个版本号（或时间戳）与变量值绑定。
- 每次修改变量时，同时更新版本号。
- 比较时不仅比较变量值，还比较版本号。
代码示例： Java 提供的 AtomicStampedReference 就是通过版本号机制解决 ABA 问题的工具。

import java.util.concurrent.atomic.AtomicStampedReference;

public class ABAExampleWithAtomicStampedReference {
    public static void main(String[] args) {
        // 创建一个 AtomicStampedReference，初始值为 1，初始版本号为 0
        AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<>(1, 0);

        // 获取初始值和版本号
        int[] stampHolder = new int[1];
        Integer initialRef = atomicStampedRef.get(stampHolder);
        int initialStamp = stampHolder[0];

        System.out.println("Initial value: " + initialRef + ", Initial stamp: " + initialStamp);

        // 模拟 ABA 问题
        new Thread(() -> {
            int stamp = atomicStampedRef.getStamp();
            System.out.println(Thread.currentThread().getName() + " - Initial stamp: " + stamp);
            atomicStampedRef.compareAndSet(1, 2, stamp, stamp + 1); // 修改值为 2，版本号 +1
            System.out.println(Thread.currentThread().getName() + " - Updated to 2");
            atomicStampedRef.compareAndSet(2, 1, stamp + 1, stamp + 2); // 再修改回 1，版本号 +1
            System.out.println(Thread.currentThread().getName() + " - Reverted to 1");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(100); // 等待 ABA 完成
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = atomicStampedRef.compareAndSet(1, 3, initialStamp, initialStamp + 1);
            System.out.println(Thread.currentThread().getName() + " - CAS result: " + result);
            System.out.println(Thread.currentThread().getName() + " - Current value: " + atomicStampedRef.getReference());
        }).start();
    }
}

输出示例：

Initial value: 1, Initial stamp: 0
Thread-0 - Initial stamp: 0
Thread-0 - Updated to 2
Thread-0 - Reverted to 1
Thread-1 - CAS result: false
Thread-1 - Current value: 1

说明：

线程 0 模拟了 ABA 问题，将值从 1 -> 2 -> 1。
线程 1 使用版本号检测到了值虽然还是 1，但版本号不一致，CAS 操作失败。

2.2 使用 `AtomicMarkableReference`

AtomicMarkableReference 使用一个标记（mark）来检测值是否被修改过。标记可以是布尔值，起到类似版本号的作用。

代码示例：

import java.util.concurrent.atomic.AtomicMarkableReference;

public class ABAExampleWithAtomicMarkableReference {
    public static void main(String[] args) {
        AtomicMarkableReference<Integer> atomicMarkableRef = new AtomicMarkableReference<>(1, false);

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " - Initial mark: " + atomicMarkableRef.isMarked());
            atomicMarkableRef.compareAndSet(1, 2, false, true); // 修改值为 2，同时更新标记
            System.out.println(Thread.currentThread().getName() + " - Updated to 2");
            atomicMarkableRef.compareAndSet(2, 1, true, false); // 修改值为 1，同时更新标记
            System.out.println(Thread.currentThread().getName() + " - Reverted to 1");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(100); // 等待 ABA 完成
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = atomicMarkableRef.compareAndSet(1, 3, false, true);
            System.out.println(Thread.currentThread().getName() + " - CAS result: " + result);
            System.out.println(Thread.currentThread().getName() + " - Current value: " + atomicMarkableRef.getReference());
        }).start();
    }
}

说明：

使用标记（mark）解决 ABA 问题。
线程 1 检测到标记变化，避免误判。

3. 应用场景

线程池工作队列：在无锁队列中，CAS 操作可能遇到 ABA 问题，需要通过版本号或标记避免问题。
栈、队列、链表操作：解决并发操作时的状态不一致问题。

4. 总结

方法	说明
版本号机制	使用版本号标识变量的每次更新，避免 ABA 问题。
`AtomicStampedReference`	提供版本号检测，解决 CAS 中的 ABA 问题。
`AtomicMarkableReference`	提供标记检测，适合简单标记的场景。