18.AtomicReference、AtomicStampReference底层原理。多个变量更新怎么保证原子性？CAS的ABA问题怎么解决？

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

 // 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("不好意思，出错了！！！！！！");
    }
}

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("运行结束了......");
    }

public class AtomicReference<V> 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); }
    }    
}

public final boolean compareAndSet(V expect, V update) {
    return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
}

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

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 boolean casPair(Pair<V> cmp, Pair<V> val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}