并发编程学习笔记（三十一、ABA问题）

目录：

• CAS操作步骤
• CAS极端情况下可能会导致的问题：ABA
• ABA问题的影响
• JUC是如何解决ABA问题的

CAS操作步骤

CAS：compare and swap，即比较后再交换。它是一种无锁的算法，操作如下：

• 从内存获取V的值。
• 拿到旧的预期值A。
• 拿到要修改的值B。
• 当且仅当预期值A和内存值V相同的时候，将内存值V修改为B；否则啥都不做。

CAS极端情况下可能会导致的问题：ABA

因为CAS并不是原子操作，所以在并发情况下可能会导致如下问题（当然锁和循环CAS的方式实现原子操作）：

• 1、线程1获取到内存值V。
• 2、线程2获取到内存值V。
• 3、线程1将内存值V改成了B。
• 4、线程2还有一些逻辑没做，还未执行到CAS操作（线程B休息了一会）。
• 5、线程1又将值A写入了V。
• 6、线程2执行CAS，发现内存值V与预期值A一致，所以执行了CAS操作，CAS成功。

此时尽管线程2的CAS操作成功了，单着并不代表这个过程是没有问题的，因为对于线程2而言，线程1执行的修改以及丢失了。

所以ABA问题只是CAS使用过程中的极端情况，某个线程将值先改成B又改成A，这样另一个线程CAS的时候会发现旧的值还是A，导致数据不对，这就是ABA问题。

ABA问题的影响

假如我们现在有一个数据结构底层基于栈实现，按照上面那种情况，就会出现如下的问题：

首先我们有一个栈，里面有A、B两个元素，A为栈顶（图1）。

执行到第4步，线程2休眠了一会，此时线程2已经知道A.next = B，将要执行CAS将栈顶替换为B。

执行第5步，线程1将A、B两个元素一次出栈，并又将D、C、A依次入栈，此时对象B处于游离状态，然后栈中元素见图2、图3。

最后当线程2执行CAS操作后，发现栈顶还是A，所以CAS成功，将栈顶替换为B；但实际上B.next = null，所以此时栈中只有B一个元素了，C和D就平白无故的丢了。

JUC是如何解决ABA问题的

上节的AtomicInteger曾说道有两个Atomic类可以避免ABA问题：

• AtomicMarkableReference：内部通过Pari承载引用对象及是否被更新过的标记，避免了BAB问题。
• AtomicStampedeReference：内部通过Pari承载引用对象及更新的邮戳，避免了BAB问题。

AtomicMarkableReference：

AtomicMarkableReference：既然ABA问题是因为需要执行CAS操作的线程无法知道值有没有更新过，那我干脆就弄一个标识，让这些线程共享这个标识的值不就可以知道原值有没有被更新过了嘛；而AtomicMarkableReference的实现正是这样的。

首先我们来看下AtomicMarkableReference是如何使用的：

public class AtomicMarkableReferenceDemo {

    /**
     * 初始值
     */
    private static final Integer INIT_NUM = 10;

    /**
     * 临时值
     */
    private static final Integer TEMP_NUM = 20;

    /**
     * 更新值
     */
    private static final Integer UPDATE_NUM = 100;

    /**
     * 更新标识
     */
    private static final Boolean INITIAL_MARK = Boolean.FALSE;

    private static AtomicMarkableReference atomicMarkableReference = new AtomicMarkableReference(INIT_NUM, INITIAL_MARK);

    public static void main(String[] args) {
        // 线程2，执行CAS操作的线程
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " ： 初始值为：" + INIT_NUM + " , 标记为： " + INITIAL_MARK);
            boolean mark = atomicMarkableReference.isMarked();
            try {
                Thread.sleep(1000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 执行CAS  10 ---> 100
            boolean result = atomicMarkableReference.compareAndSet(INIT_NUM, UPDATE_NUM, mark, Boolean.TRUE);
            System.out.println("AtomicMarkableReference发生ABA后的执行结果=" + result);
        }, "线程A").start();

        // 线程1，修改内存值的线程
        new Thread(() -> {
            Thread.yield();
            // 初始态
            System.out.println(Thread.currentThread().getName() + " ： 初始值为：" + atomicMarkableReference.getReference() + " , 标记为： " + INITIAL_MARK);
            // CAS修改  10 ---> 20
            atomicMarkableReference.compareAndSet(atomicMarkableReference.getReference(), TEMP_NUM, atomicMarkableReference.isMarked(), Boolean.TRUE);
            System.out.println(Thread.currentThread().getName() + " ： 修改后的值为：" + atomicMarkableReference.getReference() + " , 标记为： " + atomicMarkableReference.isMarked());
            // CAS修改  20 ---> 10
            atomicMarkableReference.compareAndSet(atomicMarkableReference.getReference(), INIT_NUM, atomicMarkableReference.isMarked(), Boolean.TRUE);
            System.out.println(Thread.currentThread().getName() + " ： 修改后的值为：" + atomicMarkableReference.getReference() + " , 标记为： " + atomicMarkableReference.isMarked());

        }, "线程B").start();
    }

}

最终会修改失败，结果如下：

线程A ： 初始值为：10 , 标记为： false
线程B ： 初始值为：10 , 标记为： false
线程B ： 修改后的值为：20 , 标记为： true
线程B ： 修改后的值为：10 , 标记为： true
AtomicMarkableReference发生ABA后的执行结果=false

原理很简单，你可以自行翻阅：就是通过Unsafe的compareAndSwapObject实现CAS，通过Pair的mark判断有没有改变值。

public boolean compareAndSet(V       expectedReference,
                             V       newReference,
                             boolean expectedMark,
                             boolean newMark) {
    Pair<V> current = pair;
    return
        expectedReference == current.reference &&
        expectedMark == current.mark &&
        ((newReference == current.reference &&
          newMark == current.mark) ||
         casPair(current, Pair.of(newReference, newMark)));
}

private static class Pair<T> {
    final T reference;
    final boolean mark;
    private Pair(T reference, boolean mark) {
        this.reference = reference;
        this.mark = mark;
    }
    static <T> Pair<T> of(T reference, boolean mark) {
        return new Pair<T>(reference, mark);
    }
}

AtomicStampedeReference：

AtomicStampedeReference的原理和makrable的原理很相似，但标记值就并非为boolean了，而是int，类似于mysql中版本号的概念，判断前后的版本号是否一致，一致则更新，不一致则失败。

public class AtomicStampedReferenceDemo {

    /**
     * AtomicInteger计数器
     */
    private static AtomicInteger atomicCounter = new AtomicInteger(100);

    /**
     * AtomicStampedReference计数器
     */
    private static AtomicStampedReference<Integer> atomicStampedCounter = new AtomicStampedReference<>(100, 0);

    /**
     * 测试代码
     */
    public static void main(String[] args) throws InterruptedException {
        // 测试AtomicInteger不会发现ABA问题
        Thread thread1 = new Thread(() -> {
            // 100变101
            atomicCounter.compareAndSet(100, 101);
            // 101变100
            atomicCounter.compareAndSet(101, 100);
        });
        // 测试线程2不会发现ABA问题
        Thread thread2 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean atomicResult = atomicCounter.compareAndSet(100, 101);
            System.out.println("发生ABA问题时，AtomicInteger执行结果= " + atomicResult);
        });

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

        // 测试AtomicStampedReference会发现ABA问题
        Thread stamped1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedCounter.compareAndSet(100, 101, atomicStampedCounter.getStamp(), atomicStampedCounter.getStamp() + 1);
            atomicStampedCounter.compareAndSet(101, 100, atomicStampedCounter.getStamp(), atomicStampedCounter.getStamp() + 1);
            System.out.println("线程stamped1获取的版本号 = " + atomicStampedCounter.getStamp());
        });
        Thread stamped2 = new Thread(() -> {
            // stamp发生变化
            int stamp = atomicStampedCounter.getStamp();
            System.out.println("线程stamped2在ABA发生前获取的版本号 = " + stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean atomicStampedResult = atomicStampedCounter.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println("发生ABA问题时，AtomicStampedReference执行结果= " + atomicStampedResult);
        });

        stamped1.start();
        stamped2.start();
    }
    
}

原理类似：

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)));
}

private static class Pair<T> {
    final T reference;
    final int stamp;
    private Pair(T reference, int stamp) {
        this.reference = reference;
        this.stamp = stamp;
    }
    static <T> Pair<T> of(T reference, int stamp) {
        return new Pair<T>(reference, stamp);
    }
}

——————————————————————————————————————————————————————————————————————