多线程系列学习：ABA问题

ABA问题，描述的是一个变量v，它的值经历A -> B ->A的变化，导致看起来好像没有变一样，其实，第二次出现的A已经不是第一次出现的A了，是被修改过的。

下面复现ABA问题，并解决

测试代码：

public class ABATest {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(2);
        AtomicInteger num = new AtomicInteger();
//        AtomicStampedReference<String> stampedReference = new AtomicStampedReference<>("A",1);
        new Thread(() -> {
            System.out.println("num 初始值为 "+num.get()+"，线程A准备设置 num 为 2");
//            System.out.println("stampedReference 初始值为 "+stampedReference.getReference()+"，线程A准备将其设置为C");
            // 模拟做其他事情...
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 线程A看到的那个0，已经是被线程B修改过的0了（num目前的状态0 - 1 - 0）
            num.compareAndSet(0,2);
//            stampedReference.compareAndSet("A", "C",1,2);
            latch.countDown();
        }).start();

        new Thread(() -> {
            System.out.println("num 初始值为 "+num.get()+"，线程B 设置 num 为 1");
//            System.out.println("stampedReference 初始值为 "+stampedReference.getReference()+"，线程B准备将其设置为B");
            num.compareAndSet(0,1);
//            stampedReference.compareAndSet("A", "B",1,2);
            System.out.println("num 初始值为 "+num.get()+"，线程B 设置 num 为 0");
//            System.out.println("stampedReference 初始值为 "+stampedReference.getReference()+"，线程B准备将其设置为A");
            num.compareAndSet(1,0);
//            stampedReference.compareAndSet("B", "A",2,3);
            latch.countDown();
        }).start();

        try {
            // 等待前面两个线程执行完
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("最终 num = "+num.get());
        // stampedReference的值，没有修改为C
//        System.out.println("最终 stampedReference = "+stampedReference.getReference()+"，stampedReference.getStamp()="+stampedReference.getStamp());
    }

测试结果：

num 初始值为 0，线程A准备设置 num 为 2
num 初始值为 0，线程B 设置 num 为 1
num 初始值为 1，线程B 设置 num 为 0
最终 num = 2

结果说明：num是AtomicInteger 类型的变量，保证其原子操作，但是并不能防止ABA情况的出现：线程A第二次看到的0是被线程B修改回来的0，并不是第一次遇到的0。

 

那么，如何解决ABA问题呢？Java提供了AtomicStampedReference类来解决，可以将上述代码的注释打开，同时将与num相关的代码注释掉即可，执行代码后就可以看到效果了：

stampedReference 初始值为 A，线程A准备将其设置为C
stampedReference 初始值为 A，线程B准备将其设置为B
stampedReference 初始值为 B，线程B准备将其设置为A
最终 stampedReference = A，stampedReference.getStamp()=3

可以看到，stampedReference 最终的值是A，也就是线程B第二次修改后的值，因为它的版本号为3，不是1。AtomicStampedReference解决ABA问题，在于它提供了一个版本号，在进行CAS操作时，不仅比较引用是否相等，还比较版本号和预期的是否一样，两者都一样才会进行更新，请看源码：

    /**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedStamp the expected value of the stamp
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

其中，stamp 可以看作是版本号，而Pair对象只是对reference 和 stamp的包装。