AtomicStampedReference源码分析

    欢迎大家搜索“小猴子的技术笔记”关注我的公众号，有问题可以及时和我交流。

    之前的文章已经介绍过CAS的操作原理，它虽然能够保证数据的原子性，但还是会有一个ABA的问题。

    那么什么是ABA的问题呢？假设有一个共享变量“num”,有个线程A在第一次进行修改的时候把num的值修改成了33。修改成功之后，紧接着又立刻把“num”的修改回了22。另外一个线程B再去修改这个值的时候并不能感知到这个值被修改过。

    换句话说，别人把你账户里面的钱拿出来去投资，在你发现之前又给你还了回去，那这个钱还是原来的那个钱吗？你老婆出轨之后又回到了你身边，还是你原来的那个老婆吗？

    为了模拟ABA的问题，我启动了两个线程访问一个共享的变量。将下面的代码拷贝到编译器中，运行进行测试：

public class ABATest {
    private final static AtomicInteger num = new AtomicInteger(100);

    public static void main(String[] args) {
        new Thread(() -> {
            num.compareAndSet(100, 101);
            num.compareAndSet(101, 100);
            System.out.println(Thread.currentThread().getName() + " 修改num之后的值：" + num.get());
        }).start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                num.compareAndSet(100, 200);
                System.out.println(Thread.currentThread().getName() + " 修改num之后的值：" + num.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

    第一个线程先进行修改把数值从100修改为101，然后在从101修改回100，这个过程其实是发成了ABA的操作。第二个线程等待3秒（为了是让第一个线程执行完毕，第二个线程在执行）之后进行值从100修改为200。按照我们的理解，第一个线程已经修改过原来的值了，那么第二个线程就不应该修改成功。但是如果你运行下面的测试用例的话，你会发现它是可以进行修改成功的，请看运行结果：

Thread-0 修改num之后的值：100
Thread-1 修改num之后的值：200

    虽然结果是符合我们的预期的：数值被成功地进行了修改，但是修改的过程却是不符合我们的预期的。

    为了解决这个问题，我们可以在修改的时候附加上一个版本号，也就是第几次修改。每次修改的时候把版本号带上，如果版本号能够对应的上的话就进行修改，如果对应不上的话就不允许进行修改。

    所以如果修改的时候带上的版本号不一致的话是不能够进行成功修改的。我们可以按照上面的原理自己进行版本号的封装，但也许会比较麻烦。因此我们可以使用JDK给我们提供的一个已经封装好的类“AtomicStampedReference”来进行我们数据的更新。我们来看看下面的这些例子：

public class AtomicStampedReferenceTest {

    private final static AtomicStampedReference<Integer> stamp = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 第1次版本号:" + stamp.getStamp());
            stamp.compareAndSet(100, 200, stamp.getStamp(), stamp.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + " 第2次版本号:" + stamp.getStamp());
            stamp.compareAndSet(200, 100, stamp.getStamp(), stamp.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + " 第2次版本号:" + stamp.getStamp());
        }).start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + " 第1次版本号:" + stamp.getStamp());
                stamp.compareAndSet(100, 400, stamp.getStamp(), stamp.getStamp() + 1);
                System.out.println(Thread.currentThread().getName() + " 获取到的值：" + stamp.getReference());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

Thread-0 第1次版本号:1
Thread-0 第2次版本号:2
Thread-0 第2次版本号:2
Thread-1 第1次版本号:2
Thread-1 获取到的值：200

    也是启动了两个线程对共享变量进行修改，但是这次不同的是带着版本号对共享变量进行的修改。下面将上面的例子进行拆解分析，研究下“AtomicStampedReference”到底为我们做了一些什么。

    首先分析共享变量的创建：构建了一个“AtomicStampedReference”对象，并且显示的赋值了100和1。

private final static AtomicStampedReference<Integer> stamp = new AtomicStampedReference<>(100, 1);

    构造函数调用了下面的源码：

public AtomicStampedReference(V initialRef, int initialStamp) {
    pair = Pair.of(initialRef, initialStamp);
}

    "initialRef"是初始值，也就是我们定义的100，“initialStamp”是我们显示声明的一个整形类型的版本号。只要在int的范围内即可，但是不要太大了， 毕竟是int如果超了就会丢失精度问题。

    然后调用了“Pair.of(initialRef, initialStamp)”，继续跟进源码查看：

    通过观察源码可以发现类“Pair”是“AtomicStampedReference”类的一个静态内部类，有两个参数的构造函数，然后把我们传递进来的初始值和版本号进行赋值给“Pair”对象。可以注意到“pair”被关键字“volatile”修饰，也就保证了内存的可见性和禁止指令的重排序。因此如果“pair”发生了变化，那么所有持有其引用的信息都会进行相应的数据更新。

    到此为止，“AtomicStampedReference”对象初始化完毕，内部包含了一个“reference”值为100， “stamp”为1的“pair”静态内部类。

    “stamp.getStamp()”目的是为了获取当前的版本号，我们在初始化的时候显示设置了一个值1，因此第一次获取到的版本号就是1。

 public int getStamp() {
    return pair.stamp;
}

    “stamp.compareAndSet(100, 200, stamp.getStamp(), stamp.getStamp() + 1);”是进行第一次CAS更新数据，这次更新的时候就带着版本号去更新了。

new Thread(() -> {
    System.out.println(Thread.currentThread().getName() + " 第1次版本号:" + stamp.getStamp());
    stamp.compareAndSet(100, 200, stamp.getStamp(), stamp.getStamp() + 1);
    System.out.println(Thread.currentThread().getName() + " 第2次版本号:" + stamp.getStamp());
    stamp.compareAndSet(200, 100, stamp.getStamp(), stamp.getStamp() + 1);
    System.out.println(Thread.currentThread().getName() + " 第2次版本号:" + stamp.getStamp());
}).start();

    还记得吗？之前的CAS比较是需要传递一个期望值和更新的值（内存中的值，底层的方法会给我们封装好 ）：

num.compareAndSet(100, 101);

    而带着版本号的CAS需要我们传递四个值，一个是期望值，一个是更新的值，还有两个就是期望的时间戳和需要更新的时间戳：

V   expectedReference // 表示预期值
V   newReference,     // 表示要更新的值
int expectedStamp,    // 表示预期的时间戳
int newStamp          // 表示要更新的时间戳

    之后进行了预期值的判断，预期时间戳的判断，要更新的值和当前的值如果一样的话，并且要更新的版本号和当前的版本号一样的话就返回成功。

private boolean casPair(Pair<V> cmp, Pair<V> val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}

    这里我们会发现在“compareAndSet”方法中最后还调用了“casPair”方法，从名字就可以看到，主要是使用CAS机制更新新的值reference和时间戳stamp。而最终调用的底层是一个本地的方法对数据进行的修改。

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

    对于需要自己进行CAS处理的地方，我们可以使用“AtomicStampedReference”来进行数据的处理。它既支持泛型，同时还可以避免传统CAS中ABA的问题，使数据更加安全。