关于java中CAS会引发的ABA问题探究

在并发环境下，为了保证并发安全问题，通常我们会进行加锁操作，比如加上synchronized关键字。但是很多情况下，我们不需要这样的重量级锁，比如说多个线程对某个int类型变量i

进行++操作,但是不加锁吧，又怕影响结果，因为i++不是一个原子操作，会出现并发问题，我们来看个案例。

public class NonAtomicIncrementDemo {
    // 共享变量
    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        // 线程数量
        int threadCount = 10;
        // 每个线程执行的操作次数
        int incrementCount = 1000;

        // 创建线程数组
        Thread[] threads = new Thread[threadCount];

        // 创建并启动线程
        for (int j = 0; j < threadCount; j++) {
            threads[j] = new Thread(() -> {
                for (int k = 0; k < incrementCount; k++) {
                    // 非原子操作 i++
                    i++;
                }
            });
            threads[j].start();
        }

        // 等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }

        // 预期结果
        int expectedResult = threadCount * incrementCount;
        // 实际结果
        int actualResult = i;

        System.out.println("预期结果: " + expectedResult);
        System.out.println("实际结果: " + actualResult);
    }
}

执行的结果

 问题原因:由于 i++ 不是原子操作，多个线程可能会同时读取 i 的值，然后对其进行加 1 操作，最后再写回。这样就可能会导致某些线程的加 1 操作被覆盖，从而使最终结果小于预期值

解决方法：可以使用 Java 提供的原子类（如 AtomicInteger）来保证 i++ 操作的原子性，或者使用 synchronized 关键字来对 i++ 操作进行同步。

以下是使用 AtomicInteger 解决该问题的示例代码：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIncrementDemo {
    // 原子整数
    private static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        // 线程数量
        int threadCount = 10;
        // 每个线程执行的操作次数
        int incrementCount = 1000;

        // 创建线程数组
        Thread[] threads = new Thread[threadCount];

        // 创建并启动线程
        for (int j = 0; j < threadCount; j++) {
            threads[j] = new Thread(() -> {
                for (int k = 0; k < incrementCount; k++) {
                    // 原子操作 incrementAndGet()
                    atomicInteger.incrementAndGet();
                }
            });
            threads[j].start();
        }

        // 等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }

        // 预期结果
        int expectedResult = threadCount * incrementCount;
        // 实际结果
        int actualResult = atomicInteger.get();

        System.out.println("预期结果: " + expectedResult);
        System.out.println("实际结果: " + actualResult);
    }
}

 

在这个示例中，使用 AtomicInteger 的 incrementAndGet() 方法来保证 i++ 操作的原子性，从而避免了线程安全问题。

incrementAndGet底层就是用了CAS操作。

CAS 的基本思路就是， 如果这个地址上的值和期望的值相等， 则给其赋予新 值， 否则不做任何事儿，但是要返回原值是多少。 自然 CAS 操作执行完成时，

在 业务上不一定完成了， 这个时候我们就会对 CAS 操作进行反复重试， 于是就有了 循环 CAS。很明显， 循环 CAS 就是在一个循环里不断的做 cas 操作， 直到成功为 止。 Java 中的 Atomic 系列的原子操作类的实现则是利用了循环 CAS来实现。

 

可是CAS也会有自己的问题。因为CAS需要在操作值的时候， 检查值有没有发生变化， 如果没有发生变化 则更新，但是如果

一个值原来是 A，变成了 B，又变成了 A，那么使用 CAS 进行 检查时会发现它的值没有发生变化，
但是实际上却变化了。

 上一段代码大家就懂了:

public class ABAProblemExample {
    // 创建一个原子整数，初始值为 A
    private static AtomicInteger atomicInteger = new AtomicInteger(100);

    public static void main(String[] args) {
        // 线程 1 模拟正常的操作
        Thread thread1 = new Thread(() -> {
            int expectedValue = atomicInteger.get();
            System.out.println("线程 1 获取到的初始值: " + expectedValue);

            // 模拟一些耗时操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 尝试使用 CAS 操作更新值
            boolean result = atomicInteger.compareAndSet(expectedValue, 200);
            if (result) {
                System.out.println("线程 1 更新值成功，新值为: " + atomicInteger.get());
            } else {
                System.out.println("线程 1 更新值失败");
            }
        });

        // 线程 2 模拟 ABA 问题
        Thread thread2 = new Thread(() -> {
            // 模拟一些延迟，确保线程 1 先获取到初始值
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 将值从 A 变为 B
            atomicInteger.compareAndSet(100, 150);
            System.out.println("线程 2 将值从 100 变为 150，当前值: " + atomicInteger.get());

            // 模拟一些操作
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 将值从 B 变回 A
            atomicInteger.compareAndSet(150, 100);
            System.out.println("线程 2 将值从 150 变回 100，当前值: " + atomicInteger.get());
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行的结果：

从执行的结果来看，大家感觉没问题啊，我线程1就是要将值变为200，结果是对的啊。看上去最终的结果是对的，那ABA问题也不是什么大问题啊。

我们思考一个问题：

在一个账户系统中，有一个原子整数表示账户余额。
用户 A 要从账户中取出 100 元，
此时系统先记录当前余额（假设为 500 元）准备进行 CAS 操作。
与此同时，用户 B 向该账户存入 100 元，之后又取出 100 元，
使得账户余额又变回 500 元。这时用户 A 的 CAS 操作会认为余额没有变化而成功执行取款操作，
但实际上账户的交易历史已经改变，可能会导致后续的账务统计、审计等功能出现错误

解决 ABA 问题的方法：
可以使用 AtomicStampedReference 类，它在进行 CAS 操作时不仅比较值，
还比较一个版本号（时间戳），从而避免 ABA 问题。
以下是使用 AtomicStampedReference 解决 ABA 问题的示例代码：

import java.util.concurrent.atomic.AtomicStampedReference;

public class SolveABAProblemExample {
    private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 0);

    public static void main(String[] args) {
        // 线程 1 模拟正常的操作
        Thread thread1 = new Thread(() -> {
            int[] stampHolder = new int[1];
            int expectedValue = atomicStampedReference.get(stampHolder);
            int expectedStamp = stampHolder[0];
            System.out.println("线程 1 获取到的初始值: " + expectedValue + "，版本号: " + expectedStamp);

            // 模拟一些耗时操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 尝试使用 CAS 操作更新值
            boolean result = atomicStampedReference.compareAndSet(expectedValue, 200, expectedStamp, expectedStamp + 1);
            if (result) {
                System.out.println("线程 1 更新值成功，新值为: " + atomicStampedReference.getReference() + "，新版本号: " + atomicStampedReference.getStamp());
            } else {
                System.out.println("线程 1 更新值失败");
            }
        });

        // 线程 2 模拟 ABA 问题
        Thread thread2 = new Thread(() -> {
            // 模拟一些延迟，确保线程 1 先获取到初始值
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            int[] stampHolder = new int[1];
            int value = atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];

            // 将值从 A 变为 B
            atomicStampedReference.compareAndSet(value, 150, stamp, stamp + 1);
            System.out.println("线程 2 将值从 100 变为 150，当前值: " + atomicStampedReference.getReference() + "，版本号: " + atomicStampedReference.getStamp());

            // 模拟一些操作
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            value = atomicStampedReference.get(stampHolder);
            stamp = stampHolder[0];

            // 将值从 B 变回 A
            atomicStampedReference.compareAndSet(value, 100, stamp, stamp + 1);
            System.out.println("线程 2 将值从 150 变回 100，当前值: " + atomicStampedReference.getReference() + "，版本号: " + atomicStampedReference.getStamp());
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 

在这个示例中，AtomicStampedReference 会同时比较值和版本号，当值和版本号都匹配时才会执行更新操作，从而避免了 ABA 问题