CAS机制中ABA问题的产生及解决方法

ABA问题，简单描述就是存在一个变量值为A，第一个线程把变量值从A改成了B，第二个线程又把变量值从B改成了A，这样，后面的线程读取这个变量的时候就会以为变量值没有发生过任何变化。

简单用程序模拟一下：

public class ABATest {

    public static void main(String[] args) {
        int iniValue = 1;
        AtomicInteger flag = new AtomicInteger(iniValue);
        CountDownLatch latch = new CountDownLatch(3);
        /**
         * 线程1 1--->2
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程1");
            flag.compareAndSet(iniValue, iniValue + 1);
            System.out.println(Thread.currentThread().getName() + "更新flag:" + iniValue + "--->" + (flag.get()));
            latch.countDown();
        }).start();
        /**
         * 线程2 2--->1
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程2");
            int value = flag.get();
            flag.compareAndSet(value, iniValue);
            System.out.println(Thread.currentThread().getName() + "更新flag:" + value + "--->" + (flag.get()));
            latch.countDown();
        }).start();
        /**
         * 线程3
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程3");
            try {
                TimeUnit.MILLISECONDS.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int value = flag.get();
            if (value == iniValue) {
                System.out.println(Thread.currentThread().getName() + "发现原来flag的值从来没有改变过啊,那我改变一下吧");
                flag.compareAndSet(value, value + 2);
                System.out.println(Thread.currentThread().getName() + "更新flag:" + value + "--->" + (flag.get()));
            }
            latch.countDown();
        }).start();
        try {
            latch.await();
            System.out.println("执行完成后flag:" + (flag.get()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

运行结果：

线程1更新flag:1--->2
线程2更新flag:2--->1
线程3发现原来flag的值从来没有改变过啊,那我改变一下吧
线程3更新flag:1--->3
执行完成后flag:3

上述代码简单重现了一下ABA问题，线程1和线程2都改变了值，但是由于两个线程改变后的值和初始值一样，导致线程3以为值从来没有修改过。

解决方法，使用AtomicStampedReference：

public class ABASolveTest {

    public static void main(String[] args) {
        int iniValue = 1;
        int iniStamp = 1000;
        AtomicStampedReference<Integer> flag = new AtomicStampedReference<Integer>(iniValue, iniStamp);
        CountDownLatch latch = new CountDownLatch(3);
        /**
         * 线程1 1--->2
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程1");
            // expectedReference:预期值
            // newReference: 新值
            // expectedStamp: 预期时间戳
            // newStamp: 新时间戳
            flag.compareAndSet(iniValue, iniValue + 1, iniStamp, iniStamp + 1);
            System.out.println(Thread.currentThread().getName() + "更新flag:" + iniValue + "--->" + (flag.getReference())
                + " 时间戳:" + (flag.getStamp()));
            latch.countDown();
        }).start();

        /**
         * 线程2 2--->1
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程2");
            int value = flag.getReference();
            int stamp = flag.getStamp();
            flag.compareAndSet(value, iniValue, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "更新flag:" + value + "--->" + (flag.getReference())
                + " 时间戳:" + (flag.getStamp()));
            latch.countDown();
        }).start();
        /**
         * 线程3
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程3");
            try {
                TimeUnit.MILLISECONDS.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int value = flag.getReference();
            int stamp = flag.getStamp();
            if (value == iniValue) { // 判断与初始化值是否相同
                if (stamp == iniStamp) { // 判断与初始化版本是否相同
                    System.out.println(Thread.currentThread().getName() + "发现原来flag的值从来没有改变过啊,那我改变一下吧");
                    flag.compareAndSet(value, value + 2, stamp, stamp + 1);
                    System.out.println(Thread.currentThread().getName() + "更新flag:" + value + "--->"
                        + (flag.getReference()) + " 时间戳:" + (flag.getStamp()));
                } else {
                    System.out.println(Thread.currentThread().getName()
                        + "发现flag的值虽然与初始值一样,但时间戳与初始时间戳不同,有线程改变过了,我就不改变了,预期时间戳" + iniStamp + ",当前时间戳" + stamp);
                }
            }
            latch.countDown();
        }).start();
        try {
            latch.await();
            System.out.println("执行完成后flag:" + (flag.getReference()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

运行结果：

线程1更新flag:1--->2 时间戳:1001
线程2更新flag:2--->1 时间戳:1002
线程3发现flag的值虽然与初始值一样,但时间戳与初始时间戳不同,有线程改变过了,我就不改变了,预期时间戳1000,当前时间戳1002
执行完成后flag:1

使用AtomicStampedReference类，我们可以知道引用变量中途被更改了几次，这样就可以有效避免ABA问题了。不过需要注意，如果时间戳重复，还是会出现ABA的问题。

此外，还有一种解决方法使用，使用AtomicMarkableReference类：

public class ABASolveTest2 {

    public static void main(String[] args) {
        int iniValue = 1;
        boolean iniMark = false;
        AtomicMarkableReference<Integer> flag = new AtomicMarkableReference<Integer>(iniValue, iniMark);
        CountDownLatch latch = new CountDownLatch(3);
        /**
         * 线程1 1--->2
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程1");
            // expectedReference:预期值
            // newReference: 新值
            // expectedMark: 预期标识
            // newMark: 新标识
            flag.compareAndSet(iniValue, iniValue + 1, iniMark, !iniMark);
            System.out.println(Thread.currentThread().getName() + "更新flag:" + iniValue + "--->" + (flag.getReference())
                + " 标示:" + (flag.isMarked()));
            latch.countDown();
        }).start();

        /**
         * 线程2 2--->1
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程2");
            int value = flag.getReference();
            boolean isMark = flag.isMarked();
            flag.compareAndSet(value, iniValue, isMark, isMark ? isMark : !isMark);
            System.out.println(Thread.currentThread().getName() + "更新flag:" + value + "--->" + (flag.getReference())
                + " 标示:" + (flag.isMarked()));
            latch.countDown();
        }).start();
        /**
         * 线程3
         */
        new Thread(() -> {
            Thread.currentThread().setName("线程3");
            try {
                TimeUnit.MILLISECONDS.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int value = flag.getReference();
            boolean isMark = flag.isMarked();
            if (value == iniValue) { // 判断与初始化值是否相同
                if (isMark == iniMark) { // 判断与初始化版本是否相同
                    System.out.println(Thread.currentThread().getName() + "发现原来flag的值从来没有改变过啊,那我改变一下吧");
                    flag.compareAndSet(value, value + 2, isMark, !isMark);
                    System.out.println(Thread.currentThread().getName() + "更新flag:" + value + "--->"
                        + (flag.getReference()) + " 标示:" + (flag.isMarked()));
                } else {
                    System.out.println(Thread.currentThread().getName()
                        + "发现flag的值虽然与初始值一样,标示与初始标识不同,有线程改变过了,我就不改变了,预期标示" + iniMark + ",当前标示" + isMark);
                }
            }
            latch.countDown();
        }).start();
        try {
            latch.await();
            System.out.println("执行完成后flag:" + (flag.getReference()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

运行结果：

线程1更新flag:1--->2 标示:true
线程2更新flag:2--->1 标示:true
线程3发现flag的值虽然与初始值一样,标示与初始标识不同,有线程改变过了,我就不改变了,预期标示false,当前标示true
执行完成后flag:1

AtomicMarkableReference使用boolean变量标示引用变量是否被更改过，这样缺点很明显，没有AtomicStampedReference使用灵活，因此只能用于某些特定情况下。