juc-atomic原子类之四：AtomicReference原子类，CAS的ABA问题，AtomicStampedReference，AtomicMarkableReference
多个变量修改的原子性
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中任意一个执行incrementAndGet是原子的；但是value1.incrementAndGet()、 value2.incrementAndGet()、value3.incrementAndGet()这三个操作合起来就不是原子的。可能thread1执行value1.incrementAndGet()操作的时候，thread2已经将三个自增操作执行完了，所以啊，thread1和thread2会相互干扰......
比如用锁也是可以的：
// 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介绍和函数列表
AtomicReference是作用是对"对象"进行原子操作。
AtomicReference函数列表
// 使用 null 初始值创建新的 AtomicReference。 AtomicReference() // 使用给定的初始值创建新的 AtomicReference。 AtomicReference(V initialValue) // 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。 boolean compareAndSet(V expect, V update) // 获取当前值。 V get() // 以原子方式设置为给定值，并返回旧值。 V getAndSet(V newValue) // 最终设置为给定值。 void lazySet(V newValue) // 设置为给定值。 void set(V newValue) // 返回当前值的字符串表示形式。 String toString() // 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。 boolean weakCompareAndSet(V expect, V update)
AtomicReference源码分析(基于JDK1.8)
在JDK1.8中AtomicReference.java的源码如下：
public class AtomicReference<V> implements java.io.Serializable { private static final long serialVersionUID = -1848883965231344442L; // 获取Unsafe对象，Unsafe的作用是提供CAS操作 private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOffset; static { try { valueOffset = unsafe.objectFieldOffset (AtomicReference.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } // volatile类型 private volatile V value; public AtomicReference(V initialValue) { value = initialValue; } public AtomicReference() { } public final V get() { return value; } public final void set(V newValue) { value = newValue; } //最终设置为给定值 public final void lazySet(V newValue) { unsafe.putOrderedObject(this, valueOffset, newValue); } //原子的修改值 public final boolean compareAndSet(V expect, V update) { return unsafe.compareAndSwapObject(this, valueOffset, expect, update); } //weakCompareAndSet操作仅保留了volatile自身变量的特性，而出去了happens-before规则带来的内存语义。 //也就是说，weakCompareAndSet无法保证处理操作目标的volatile变量外的其他变量的执行顺序( 编译器和处理器为了优化程序性能而对指令序列进行重新排序 )， //同时也无法保证这些变量的可见性.在jdk9中可体现 public final boolean weakCompareAndSet(V expect, V update) { return unsafe.compareAndSwapObject(this, valueOffset, expect, update); } @SuppressWarnings("unchecked") public final V getAndSet(V newValue) { return (V)unsafe.getAndSetObject(this, valueOffset, newValue); } public final V getAndUpdate(UnaryOperator<V> updateFunction) { V prev, next; do { prev = get(); next = updateFunction.apply(prev); } while (!compareAndSet(prev, next)); return prev; } public final V updateAndGet(UnaryOperator<V> updateFunction) { V prev, next; do { prev = get(); next = updateFunction.apply(prev); } while (!compareAndSet(prev, next)); return next; } public final V getAndAccumulate(V x, BinaryOperator<V> accumulatorFunction) { V prev, next; do { prev = get(); next = accumulatorFunction.apply(prev, x); } while (!compareAndSet(prev, next)); return prev; } public final V accumulateAndGet(V x, BinaryOperator<V> accumulatorFunction) { V prev, next; do { prev = get(); next = accumulatorFunction.apply(prev, x); } while (!compareAndSet(prev, next)); return next; } }
说明：
AtomicReference的源码比较简单。它是通过"volatile"和"Unsafe提供的CAS函数实现"原子操作。
(1) value是volatile类型。这保证了：当某线程修改value的值时，其他线程看到的value值都是最新的value值，即修改之后的volatile的值。
(2) 通过CAS设置value。这保证了：当某线程池通过CAS函数(如compareAndSet函数)设置value时，它的操作是原子的，即线程在操作value时不会被中断。
三、AtomicReference底层原理
AtomicReference实现一个对象原子更新
package com.dxz; import java.util.concurrent.atomic.AtomicReference; public class ReferenceDemo { // 声明一个AtomicReference，封装Demo对象的 private static AtomicReference<Demo> 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("运行结束了......"); } }
运行结果：
C:\java\jdk1.8.0_111\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.2\lib\idea_rt.jar=31507:C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.2\lib\idea_rt.jar" com.intellij.rt.execution.CommandLineWrapper C:\Users\4cv748wpd3\AppData\Local\Temp\idea_classpath82421684 com.dxz.ReferenceDemo
运行结束了......
Process finished with exit code 0
结果说明：
并没有打印报错信息。它这里啊相当于把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替换操作。
结合源代码，跟Atomicinteger和AtomicBoolean原理是一样的是：
- 一方面：成员变量是volatile修饰的V泛型变量。volatile保证了可见性和顺序性。
- 另一方面：修改类的方法都是通过unsafe的cas实现，unsafte保证了原子性。
不同的是：只不过AtomicInteger、AtomicBoolean底层调用的是unsafe.compareAndSwapInt方法CAS操作int的值，而这里是compareAndSwapObject是CAS操作一个内存对象而已。
四、CAS的ABA问题
在CAS算法中，需要取出内存中某时刻的数据（由用户完成），在下一时刻比较并替换（由CPU完成，该操作是原子的）。这个时间差中，会导致数据的变化。ABA问题是这样子的：
如果待修改的值在CAS执行第二步的过程中被其他线程访问并修改，并且在第三步之前又修改为最初的值，例如先+1再-1。
此时虽然线程A的CAS执行成功，但是值已经不是最初的值了。
怎么避免ABA这种问题？
这个应该是多增加一个维度，比如版本号，每一次修改数据版本号则递增1，然后执行CAS操作的时候多一个版本号维度判断，这样就能避免ABA问题了。
五、AtomicStampedReference原理
Atomic原子类系列里面有一个类叫做AtomicStampedReference，是AtomicReference的升级版本，看名字你就知道多了一个叫做Stamped的东西，这东西就是版本号，也叫作邮戳。下面让我们看看AtomicStampedReference的内部结构和核心方法。
AtomicStampedReference的内部结构：
public class AtomicStampedReference<V> { // 将当前对象引用和修改的版本号绑定成一个pair对 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; }
这里比较上面的AtomicReference多了一个stamp版本号，将对象和版本号绑定在一起，形成一对pair，比较的时候同时比较对象的引用和版本号，避免ABA问题。
核心执行修改的CAS方法：
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))); }
（1）获取旧的对象引用expectedRefenence
（2）执行CAS操作前，获取当前内存最新的数据
（3）对比旧的对象和当前对象的reference引用是否同一个，版本号stamp是否相同
（4）如果相同执行CAS操作替换，否则不一样说明有别的线程修改过数据，CAS操作失败
casPair方法：直接调用底层的unsafe类的compareAndSwapObject方法直接替换一个对象：
private boolean casPair(Pair<V> cmp, Pair<V> val) { return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val); }
其实就是比AtomicReference多了一个版本号stamped，在执行CAS操作之前对比reference的值的同时也对比版本号，如果reference一样但是stamped不一样，说明期间有人修改过但是又把值改回来了，就不允许执行CAS操作了，这样就能解决ABA的问题了。
AtomicMarkableReference跟AtomicStampedReference差不多，
AtomicStampedReference是使用pair的int stamp作为计数器使用，AtomicStampedReference可能关心的是改动过几次，
AtomicMarkableReference的pair使用的是boolean mark，AtomicMarkableReference关心的是有没有被人动过，方法都比较简单。
