526互联

【Java 并发】【八】【Atomic】【三】AtomicReference、AtomicStampReference原理

发布时间 2023-04-04 07:05:16作者: 酷酷-

1  前言

上节我们看了AtomicInteger、AtomicBoolean的原理，这一篇我们就来说说Atomic系列的另一个分类AtomicReference和AtomicStampReference。

2  多个变量修改的原子性

JUC虽然提供了AtomicInteger、AtomicBoolean这些基本类型的原子类，但是啊有些场景并不是仅仅修改一个变量那么简单，有可能某个需要修改几个变量，但是需要这个操作具有原子性，比如：

（1）假如有三个变量，value1、value2、value3，我需要他们都两两相等
（2）这时将value1、value2、value3都声明成AtomicInteger原子类
（3）定义一个线程类，创建两个线程实例，每个都执行5000次value1、value2、value3的操作
（4）每次操作完成之后对比value1、value2、value3是否两两相等，如果不满足，则打印报错。

public class MultiUpdateDemo extends Thread {
    // 声明三个AtomicInteger的原子类
    private static AtomicInteger value1 = new AtomicInteger(0);
    private static AtomicInteger value2 = new AtomicInteger(0);
    private static AtomicInteger value3 = new AtomicInteger(0);

    // 定义一个线程，执行3个AtomicInteger的++操作
    @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 {
        // 创建两个线程，并发的操作
        MultiUpdateDemo demo1 = new MultiUpdateDemo();
        MultiUpdateDemo demo2 = new MultiUpdateDemo();
        // 启动两个线程
        demo1.start();
        demo2.start();
        // 等待两个线程执行完
        demo1.join();
        demo2.join();
    }
}

其实原因大家应该能想到，单独对value1、value2、value3中任意一个执行incrementAndGet是原子的；但是value1.incrementAndGet()、 value2.incrementAndGet()、value3.incrementAndGet()这三个操作合起来就不是原子的，可能thread1执行value1.incrementAndGet()操作的时候，thread2已经将三个自增操作执行完了，所以啊，thread1和thread2会相互干扰。像是这种情况啊要对多个变量进行操作，同时又要保证这个操作具有原子性，单独使用AtomicInteger、AtomicBoolean是做不到的。

可能大家会想到：

// 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的更新多个变量，确保原子性。

3  AtomicReference原理

AtomicReference实现一个对象原子更新，我们先把上边的例子改造一下：

public class MultiUpdateDemo extends Thread {
    // 声明一个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;
    }

    // 定义一个线程，执行3个AtomicInteger的++操作
    @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 {
        // 创建两个线程，并发的操作
        MultiUpdateDemo demo1 = new MultiUpdateDemo();
        MultiUpdateDemo demo2 = new MultiUpdateDemo();
        // 启动两个线程
        demo1.start();
        demo2.start();
        // 等待两个线程执行完
        demo1.join();
        demo2.join();
    }
}

并没有打印报错信息。它这里啊相当于把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替换操作。

3.1  AtomicReference底层剖析

首先看一下AtomicReference的内部属性：

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

看下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操作一个内存对象而已，没啥大区别。

AtomicInteger、AtomicBoolean 执行的是unsafe的compareAndSwapInt方法，在内存层次是直接替换一个int变量的值；然而使用AtomicRefernce你可以创建一个新的对象，将所有的数据变更操作放到新对象里面，然后底层调用unsafe.compareAndSwapObject方法直接替换成新对象。

3.2  CAS的ABA问题

CAS操作不可避免的问题之一就是ABA问题，我画个图说一下对ABA问题的理解：

（1）线程1要执行CAS操作前，读取value最新的值为A
（2）然后线程2在这期间将内存value的数据修改成B，然后又修改回了A；
（3）但是线程A不知道，执行CAS操作的时候发现值还是A，以为没人修改过value的值，也是就执行执行CAS操作成功了

那应该怎么避免ABA这种问题？这个应该是多增加一个维度，比如版本号，每一次修改数据版本号则递增1，然后执行CAS操作的时候多一个版本号维度判断，这样就能避免ABA问题了。

3.3  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多了一个版本号stamp，在执行CAS操作之前对比reference的值的同时也对比版本号，如果reference一样但是stamp不一样，说明期间有人修改过但是又把值改回来了，就不允许执行CAS操作了，这样就能解决ABA的问题了。

4  小结

好了这节我们看了AtomicReference和AtomicStampReference，AtomicReference是用于修改多个属性的原子性操作，将要修改的属性封装进某个对象， 对整个对象进行CAS；AtomicStampReference是用于解决ABA问题，增加版本号的机制来实现，有理解不对的地方欢迎指正哈。