关于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来实现。