老王：小陈啊，上一章我们说了AtomicInteger、AtomicBoolean的底层原理，这一篇我们就来说说Atomic系列的另一个分类AtomicReference和AtomicStampReference。
小陈：老王啊，我有个疑问啊，java不是提供了AtomicInteger、AtomicBoolean这些原子类了吗？为什么还需要有AtomicReference这东西啊？
老王：JUC虽然提供了AtomicInteger、AtomicBoolean这些基本类型的原子类，但是啊有些场景并不是仅仅修改一个变量那么简单，有可能某个需要修改几个变量，但是需要这个操作具有原子性，比如说我给你举例的这个例子：
（1）假如有三个变量，value1、value2、value3，我需要他们都两两相等
（2）这时将value1、value2、value3都声明成AtomicInteger原子类
（3）定义一个线程类，创建两个线程实例，每个都执行5000次value1、value2、value3的操作
（4）每次操作完成之后对比value1、value2、value3是否两两相等，如果不满足，则打印报错
public class MultiUpdateDemo { // 声明三个AtomicInteger的原子类 private static AtomicInteger value1 = new AtomicInteger(0); private static AtomicInteger value2 = new AtomicInteger(0); private static AtomicInteger value3 = new AtomicInteger(0); // 定义一个线程，执行3个AtomicInteger的++操作 public static class MultiUpdateThread extends Thread{ @Override public void run() { for (int i = 0; i < 5000; i++) { value1.incrementAndGet(); value2.incrementAndGet(); value3.incrementAndGet(); // 假如说执行完一次操作之后，出现 // value1、value2、value3任何两两不相等的情况 // 则打印报错 if (value1.get() != value2.get() || value1 != value3 || value2.get() != value3.get()) { System.out.println("不好意思，出错了！！！！！！"); } } } } public static void main(String[] args) throws InterruptedException { // 创建两个线程，并发的操作 MultiUpdateThread thread1 = new MultiUpdateThread(); MultiUpdateThread thread2 = new MultiUpdateThread(); thread1.start(); thread2.start(); thread1.join(); thread2.join(); } }
具体得到的实验结果如下：
老王：根据样例的实验结果啊，出现和很多次value1、value2、value3不相等的情况，也就是我们需要的目的没有达到，小陈啊，你知道这是什么原因吗？
小陈：老王啊，我想了一下单独对value1、value2、value3中任意一个执行incrementAndGet是原子的；但是value1.incrementAndGet()、 value2.incrementAndGet()、value3.incrementAndGet()这三个操作合起来就不是原子的。
可能thread1执行value1.incrementAndGet()操作的时候，thread2已经将三个自增操作执行完了，所以啊，thread1和thread2会相互干扰......
老王：哈哈，小陈啊，看来我没看错你啊，挺聪明的哦。像是这种情况啊要对多个变量进行操作，同时又要保证这个操作具有原子性，单独使用AtomicInteger、AtomicBoolean是做不到的。
小陈：老王，如果使用到锁不可以吗，比如我可以将上面的几个操作放到synchronized代码块里面：
// lock锁对象是一个共享变量 synchronized(lock) { value1.incrementAndGet(); value2.incrementAndGet(); value3.incrementAndGet(); // 加入说执行完一次操作之后，出现value1、value2、value3任何两两不相等的情况 if (value1.get() != value2.get() || value1 != value3 || value2.get() != value3.get()) { System.out.println("不好意思，出错了！！！！！！"); } }
老王：这种情况下使用synchronized是可以保证原子性的，但是使用到锁啊，那并发性能就下降了很多了，因为在竞争激烈的时候可能会导致很多线程获取不到锁而挂起，那开销就大了，这个我们在之前的synchronized的重量级锁章节里面专门分析过了。
小陈：哦哦，原来是这样啊......
老王：嗯嗯，AtomicIntegter只能确保自己本身操作具有原子性，但是多个AtomicInteger操作合起来这个是确保不了的；可以使用synchronized将多个操作包含起来，但是使用到synchronized的锁操作势必会降低一部分并发的性能。
小陈：那怎样在不使用锁的情况下保证多个变量的修改是具有原子性的呢？
老王：哈哈，这个时候就需要用到Atomic给我们提供的另外一个类了，AtomicReference。它可以将多个变量封装为对象的多个属性，然后一次性的更新整个对象，就能cas的更新多个变量，确保原子性。
AtomicReference实现一个对象原子更新
public class ReferenceDemo { // 声明一个AtomicReference，封装Demo对象的 private static AtomicReference reference = new AtomicReference(new Demo()); // 将value1、value2、value3封装为Demo对象的属性 public static class Demo { public int value1 = 0; public int value2 = 0; public int value3 = 0; } // 创建线程累专门执行对象的更新 public static class ReferenceThread extends Thread { @Override public void run() { for (int i = 0; i < 5000; i++) { Demo expected; Demo update; // 直到CAS更新操作成功才退出 do { expected = reference.get(); update = new Demo(); update.value1 = expected.value1 + 1; update.value2 = expected.value2 + 1; update.value3 = expected.value2 + 1; } while (!reference.compareAndSet(expected, update)); // 获取CAS之后的最新对象 Demo curDemo = reference.get(); // 如果value1、value2、value3中有任意一个不相等，打印报错 if (curDemo.value1 != curDemo.value2 || curDemo.value2 != curDemo.value3 || curDemo.value1 != curDemo.value3) { System.out.println("不好意思，出错了！！！！！！"); } } } } public static void main(String[] args) throws InterruptedException { // 创建两个线程，并发的操作，验证并发操作的原子性 ReferenceThread thread1 = new ReferenceThread(); ReferenceThread thread2 = new ReferenceThread(); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println("运行结束了......"); }
实测结果如下：
并没有打印报错信息。它这里啊相当于把value1、value2、value3的更新操作变为了对象的更新操作，这样原本的3次操作就变为了一次CAS操作，这样就能保证原子性了。
小陈：原来是这样啊，原来是多个数据变更的操作变为一个对象变更操作；由于AtomicReference提供了对象替换的CAS操作，所以上面的操作就具有原子性了。
老王：是的，就是这个道理，画个图来解析它的步骤，就是这样的：
（1）将多个变量封装在一个对象中，比如demo对象，封装了value1、value2、value3变量的值，此时三个变量均为0
（2）此时要将3个变量的值均更新为1，则新创建一个对象update封装value1、value2、value3的值均为1
（3）此时只需要将旧的demo对象通过cas操作替换为新的update对象即可，这样就将多个变量的更新操作变为了一个对象的cas替换操作。
老王：让我们继续，来看看AtomicReference底层有什么东西？
AtomicReference原子类底层剖析
首先看一下AtomicReference的内部属性：
public class AtomicReference implements java.io.Serializable { // unsafe对象 private static final Unsafe unsafe = Unsafe.getUnsafe(); // 一个泛型对象 private volatile V value; // value对象在AtomicReference内部的偏移量 private static final long valueOffset; static { try { // 获取value相对AtomicReference的内部偏移量 valueOffset = unsafe.objectFieldOffset (AtomicReference.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } }
看下compareAndSet方法的内部源码：
public final boolean compareAndSet(V expect, V update) { return unsafe.compareAndSwapObject(this, valueOffset, expect, update); }
看样子跟Atomicinteger和AtomicBoolean原理是一样的，只不过AtomicInteger、AtomicBoolean底层调用的是unsafe.compareAndSwapInt方法CAS操作int的值，而这里是compareAndSwapObject是CAS操作一个内存对象而已，没啥大区别。
小陈：看样子这个AtomicReference也是挺简单的呀，唯一与AtomicInteger、AtomicBoolean不同的是：
AtomicInteger、AtomicBoolean 执行的是unsafe的compareAndSwapInt方法，在内存层次是直接替换一个int变量的值；然而使用AtomicRefernce你可以创建一个新的对象，将所有的数据变更操作放到新对象里面，然后底层调用unsafe.compareAndSwapObject方法直接替换成新对象啊。
老王：哈哈，看来你把AtomicReference理解透了啊？也是，本来就不难嘛，就是把多个修改放在对象里面，直接CAS替换对象就是了
老王：小陈啊，学到了这里，你对CAS的理解也差不多了，可以算的是深入了，但是你知道CAS操作会有什么问题吗？
小陈：这个啊，我经常看到一些网站上说CAS操作不可避免的问题之一就是ABA问题？
老王：那你知道什么是ABA问题？
小陈：老王啊，我画个图说一下我对ABA问题的理解吧，是这样的：
（1）线程1要执行CAS操作前，读取value最新的值为A
（2）然后线程2在这期间将内存value的数据修改成B，然后又修改回了A；
（3）但是线程A不知道，执行CAS操作的时候发现值还是A，以为没人修改过value的值，也是就执行执行CAS操作成功了
老王：那应该怎么避免ABA这种问题？
小陈：这个应该是多增加一个维度，比如版本号，每一次修改数据版本号则递增1，然后执行CAS操作的时候多一个版本号维度判断，这样就能避免ABA问题了。
老王：是的，确实是需要多一个版本号维度去判断，那你知道Atomic原子类里面哪个类能解决这个问题吗？
小陈：啊，这个......我就不知道啊，还是老王你来讲讲吧。
老王：哈哈，好。Atomic原子类系列里面有一个类叫做AtomicStampedReference，是AtomicReference的升级版本，看名字你就知道多了一个叫做Stamped的东西，这东西就是版本号，也叫作邮戳。下面让我们看看AtomicStampedReference的内部结构和核心方法。
AtomicStampedReference
内部结构：
public class AtomicStampedReference { // 将当前对象引用和修改的版本号绑定成一个pair对 private static class Pair { // 对象引用 final T reference; // 版本号 final int stamp; private Pair(T reference, int stamp) { this.reference = reference; this.stamp = stamp; } static Pair of(T reference, int stamp) { return new Pair(reference, stamp); } } private volatile Pair pair; }
这里比较上面的AtomicReference多了一个stamp版本号，将对象和版本号绑定在一起，形成一对pair，比较的时候同时比较对象的引用和版本号，避免ABA问题。
核心执行修改的CAS方法：
public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp) { // 这里获取当前的版本号和对象 Pair current = pair; return // 这里对比对象是否被修改过，如果被修改过，则对象引用变化了 expectedReference == current.reference && // 比较版本号是否一致 expectedStamp == current.stamp && ((newReference == current.reference && newStamp == current.stamp) || casPair(current, Pair.of(newReference, newStamp))); }
（1）获取旧的对象引用expectedRefenence
（2）执行CAS操作前，获取当前内存最新的数据
（3）对比旧的对象和当前对象的reference引用是否同一个，版本号stamp是否相同
（4）如果相同执行CAS操作替换，否则不一样说明有别的线程修改过数据，CAS操作失败
casPair方法：
直接调用底层的unsafe类的compareAndSwapObject方法直接替换一个对象：
private boolean casPair(Pair cmp, Pair val) { return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val); }
让我们再画一张图来捋一捋：
老王：小陈啊，AtomicStampedReference的底层原理通过上面的代码和画图讲解，你听懂了没？
小陈：某问题了，其实就是比AtomicReference多了一个版本号stamped，在执行CAS操作之前对比reference的值的同时也对比版本号，如果reference一样但是stamped不一样，说明期间有人修改过但是又把值改回来了，就不允许执行CAS操作了，这样就能解决ABA的问题了。
老王：没错，理解完全正确。
小陈：老王啊，接下来我们学习什么？
老王：接下来啊，我们讲解Atomic系列中的下一章《Atomic系列之LongAdder的底层原理（分段锁提升并发性能） 》
小陈：牛逼plus......，我们下一章见。
