解决ABA问题

解决ABA问题

一、ABA问题简述

在使用无锁CAS的时候，一个线程会先获取变量的值，比较的时候再获取内存中的值，如果一致就表示没有被其他线程修改过，然后就执行交换操作，但是如果一个线程修改了，然后另一个线程又修改为原来的值，这个时候一比较还是一样的。也就是说线程无法感知变量是否被修改过。

二、解决方法

使用AtomicStampedReference和版本号解决ABA问题，当前线程可以感知到值是否发生变化。

@Slf4j(topic = "c.atomicStampedReference")
public class AtmoicStampedRefInstance {
    
    private static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
    
    public static void main(String[] args) throws InterruptedException {
        log.info("main start...");
        String prev = ref.getReference();
        int stamp = ref.getStamp();
        log.info("{}", stamp);
        other();
        Thread.sleep(1000);
        //其他线程已经修改过了，CAS会失败，除了比较值还会比较版本号
        log.info("{}", stamp);
        log.info("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
    }
    
    private static void other() throws InterruptedException {
        new Thread(() -> {
            int stamp = ref.getStamp();
            log.info("{}", stamp);
            log.info("change A->B {}", ref.compareAndSet(prev, "B", stamp, stamp + 1));
        }, "t1").start();
        new Thread(() -> {
            int stamp = ref.getStamp();
            log.info("{}", stamp);
            log.info("change B->A {}", ref.compareAndSet(prev, "A", stamp, stamp + 1));
        }, "t2").start();
    }
}

三、源码解析

/**
 * 维护了一个对象引用以及一个整型变量stamp
 */
public class AtomicStampedReference<V> {
    
    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);
        }
    }
    
    private volatile Pair<V> pair;
    
    /**
     * 使用给定的初始值来创建一个新的对象
     */
    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
    
    /**
     * 返回引用对象的当前值
     */
    public V getReference() {
        return pair.reference;
    }
    
    /**
     * 返回stamp的当前值
     */
    public int getStamp() {
        return pair.stamp;
    }
    
    /**
     * 如果当前引用与期望的引用相同并且当前的stamp与期望的stamp相同，更新引用与stamp
     * @param expectedReference 期望的引用值
     * @param newReference 引用的新值
     * @param expectedStamp 期望的stamp值
     * @param newStamp 新的stamp值
     * @return 成功返回true
     */
    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)));
    }
    
    //...
}