史上最简单易懂的 AtomicReference 源码解析和使用

╰+攻爆jí腚メ 2022-05-09 13:36 142阅读 0赞

1、作用：

1、概述：是对 ”对象” 进行原子操作，用于描述的原子包规范原子变量的性质
       提供了一种读和写都是原子性的对象引用变量。
       原子意味着多个线程试图改变同一个AtomicReference(例如比较和交换操作)将不会使得AtomicReference处于不一致的状态。
    2、 AtomicReference 和 AtomicInteger 非常类似，不同之处就在于 AtomicInteger 是对整数的封装，
       而 AtomicReference 则对应普通的对象引用。也就是它可以保证你在修改对象引用时的线程安全性。
       在介绍 AtomicReference 的同时，我希望同时提出一个有关原子操作的逻辑上的不足。
       《 线程判断被修改对象是否可以正确写入的条件是对象的当前值和期望是否一致。这个逻辑从一般意义上来说是正确的。
          但有可能出现一个小小的例外，就是当你获得对象当前数据后，在准备修改为新值前，对象的值被其他线程连续修改了2次，
          而经过这2次修改后，对象的值又恢复为旧值。这样，当前线程就无法正确判断这个对象究竟是否被修改过 
       》

2、案例：

一般来说，发生这种情况的概率很小。而且即使发生了，可能也不是什么大问题。比如，我们只是简单得要做一个数值加法，即使在我取得期望值后，这个数字被不断的修改，只要它最终改回了我的期望值，我的加法计算就不会出错。也就是说，当你修改的对象没有过程的状态信息，所有的信息都只保存于对象的数值本身。

但是，在现实中，还可能存在另外一种场景。就是我们是否能修改对象的值，不仅取决于当前值，还和对象的过程变化有关，这时，AtomicReference 就无能为力了。

打一个比方，如果有一家蛋糕店，为了挽留客户，绝对为贵宾卡里余额小于20元的客户一次性赠送20元，刺激消费者充值和消费。但条件是，每一位客户只能被赠送一次。

现在，我们就来模拟这个场景，为了演示 AtomicReference，我在这里使用 AtomicReference 实现这个功能。首先，我们模拟用户账户余额。

1、定义用户账户余额： 
    
    static AtomicReference<Integer> money=newAtomicReference<Integer>();
    
    money.set(19);			//	设置账户初始值小于20，显然这是一个需要被充值的账户

2、接着，我们需要若干个后台线程，它们不断扫描数据，并为满足条件的客户充值。
    
    //	模拟多个线程同时更新后台数据库，为用户充值
    for(int i = 0 ; i < 3 ; i++) {            
        new Thread(){
    		publicvoid run() {
    			while(true){
                    while(true) {
                        Integer m = money.get();
                        if(m < 20){
                            if(money.compareAndSet(m, m + 20)) {
                      			 System.out.println("余额小于20元，充值成功，余额:" + money.get() + "元");
                                 break;
                            }
                        } else {
                         	 System.out.println("余额大于20元，无需充值");
                             break ;
                        }
                     }
                 }
             }
         }.start();
     }

上述代码第8行，判断用户余额并给予赠予金额。如果已经被其他用户处理，那么当前线程就会失败。  
因此，可以确保用户只会被充值一次。

此时，如果很不幸的，用户正好正在进行消费，就在赠予金额到账的同时，他进行了一次消费，使得总金额又小于20元，并且正好累计消费了20元。使得消费、赠予后的金额等于消费前、赠予前的金额。这时，后台的赠予进程就会误以为这个账户还没有赠予，所以，存在被多次赠予的可能。下面，模拟了这个消费线程：

//	用户消费线程，模拟消费行为
     new Thread() {
         public voidrun() {
             for(inti = 0; i < 100; i++) {
                while(true) {
                    Integer m = money.get();
                     if(m > 10){
                        System.out.println("大于10元");
                        if(money.compareAndSet(m, m - 10)) {
                            System.out.println("成功消费10元，余额:" + money.get());
                            break;
                        }
                    }else{
                        System.out.println("没有足够的金额");
                        break;
                     }
                 }
                 
                 try{Thread.sleep(100);} catch (InterruptedException e) {}
             }
         }
     }.start();

上述代码中，消费者只要贵宾卡里的钱大于10元，就会立即进行一次10元的消费。执行上述程序，

得到的输出如下：

余额小于20元，充值成功，余额:39元
    大于10元
    成功消费10元，余额:29
    大于10元
    成功消费10元，余额:19
    余额小于20元，充值成功，余额:39元
    大于10元
    成功消费10元，余额:29
    大于10元
    成功消费10元，余额:39
    余额小于20元，充值成功，余额:39元

从这一段输出中，可以看到，这个账户被先后反复多次充值。其原因正是因为账户余额被反复修改，修改后的值等于原有的数值。使得CAS操作无法正确判断当前数据状态。

虽然说这种情况出现的概率不大，但是依然是有可能的出现的。因此，当业务上确实可能出现这种情况时，我们也必须多加防范。体贴的JDK也已经为我们考虑到了这种情况，使用AtomicStampedReference就可以很好的解决这个问题。

3、源码：

1、个人介绍源码：
    
    public class AtomicReference<V> implements Serializable {
        private static final long serialVersionUID = -1848883965231344442L;
        private static final Unsafe unsafe = Unsafe.getUnsafe();				//	通过 unsafe 实现原子操作
        private static final long valueOffset;
        private volatile V value;												//	通过 volatile 实现原子操作
    
        public AtomicReference(V var1) {
        
            this.value = var1;
        }
    
        public AtomicReference() {
        }
    
        //	通过 volatile 实现原子操作
        public final V get() {
        
            return this.value;
        }
    
        //	非原子操作-慎用
        public final void set(V var1) {
        
            this.value = var1;
        }
    
        //	通过 unsafe 实现原子操作
        public final void lazySet(V var1) {
        
            unsafe.putOrderedObject(this, valueOffset, var1);
        }
    
        //	通过 unsafe 实现原子操作
         /**
             * var1当前值：拿当前值value和var1值去比较，如果相等返回true并更新值为var2期望值
             * var2期望值：如果返回true则更新为期望值，如果返回false则不更新值
             */
        public final boolean compareAndSet(V var1, V var2) {
        
            return unsafe.compareAndSwapObject(this, valueOffset, var1, var2);
        }
    
        //通过 unsafe 实现原子操作
        public final boolean weakCompareAndSet(V var1, V var2) {
        
            return unsafe.compareAndSwapObject(this, valueOffset, var1, var2);
        }
    
        //通过 unsafe 实现原子操作
        public final V getAndSet(V var1) {
        
            return unsafe.getAndSetObject(this, valueOffset, var1);
        }
    
        //.....省略.....
    }

volatile：多线程读写过程中能够保持它们的可见性。即要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。 当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

value 是 volatile 类型，保证 value 值永远是最新的 value 值，线程在操作 value 时不会被中断。

通过Unsafe.compareAndSwapObject设置的value，保证操作是原子性的，线程在操作value时不会被中断。

2、java class 源码
    
    package java.util.concurrent.atomic;
    import java.util.function.UnaryOperator;
    import java.util.function.BinaryOperator;
    import sun.misc.Unsafe;
    
    /**
     * An object reference that may be updated atomically. See the {@link
     * java.util.concurrent.atomic} package specification for description
     * of the properties of atomic variables.
     * @since 1.5
     * @author Doug Lea
     * @param <V> The type of object referred to by this reference
     */
    public class AtomicReference<V> implements java.io.Serializable {
        private static final long serialVersionUID = -1848883965231344442L;
    
        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); }
        }
    
        private volatile V value;
    
        /**
         * Creates a new AtomicReference with the given initial value.
         *
         * @param initialValue the initial value
         */
        public AtomicReference(V initialValue) {
            value = initialValue;
        }
    
        /**
         * Creates a new AtomicReference with null initial value.
         */
        public AtomicReference() {
        }
    
        /**
         * Gets the current value.
         *
         * @return the current value
         */
        public final V get() {
            return value;
        }
    
        /**
         * Sets to the given value.
         *
         * @param newValue the new value
         */
        public final void set(V newValue) {
            value = newValue;
        }
    
        /**
         * Eventually sets to the given value.
         *
         * @param newValue the new value
         * @since 1.6
         */
        public final void lazySet(V newValue) {
            unsafe.putOrderedObject(this, valueOffset, newValue);
        }
    
        /**
         * Atomically sets the value to the given updated value
         * if the current value {@code ==} the expected value.
         * @param expect the expected value
         * @param update the new value
         * @return {@code true} if successful. False return indicates that
         * the actual value was not equal to the expected value.
         */
        public final boolean compareAndSet(V expect, V update) {
            return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
        }
    
        /**
         * Atomically sets the value to the given updated value
         * if the current value {@code ==} the expected value.
         *
         * <p><a href="package-summary.html#weakCompareAndSet">May fail
         * spuriously and does not provide ordering guarantees</a>, so is
         * only rarely an appropriate alternative to {@code compareAndSet}.
         *
         * @param expect the expected value
         * @param update the new value
         * @return {@code true} if successful
         */
        public final boolean weakCompareAndSet(V expect, V update) {
            return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
        }
    
        /**
         * Atomically sets to the given value and returns the old value.
         *
         * @param newValue the new value
         * @return the previous value
         */
        @SuppressWarnings("unchecked")
        public final V getAndSet(V newValue) {
            return (V)unsafe.getAndSetObject(this, valueOffset, newValue);
        }
    
        /**
         * Atomically updates the current value with the results of
         * applying the given function, returning the previous value. The
         * function should be side-effect-free, since it may be re-applied
         * when attempted updates fail due to contention among threads.
         *
         * @param updateFunction a side-effect-free function
         * @return the previous value
         * @since 1.8
         */
        public final V getAndUpdate(UnaryOperator<V> updateFunction) {
            V prev, next;
            do {
                prev = get();
                next = updateFunction.apply(prev);
            } while (!compareAndSet(prev, next));
            return prev;
        }
    
        /**
         * Atomically updates the current value with the results of
         * applying the given function, returning the updated value. The
         * function should be side-effect-free, since it may be re-applied
         * when attempted updates fail due to contention among threads.
         *
         * @param updateFunction a side-effect-free function
         * @return the updated value
         * @since 1.8
         */
        public final V updateAndGet(UnaryOperator<V> updateFunction) {
            V prev, next;
            do {
                prev = get();
                next = updateFunction.apply(prev);
            } while (!compareAndSet(prev, next));
            return next;
        }
    
        /**
         * Atomically updates the current value with the results of
         * applying the given function to the current and given values,
         * returning the previous value. The function should be
         * side-effect-free, since it may be re-applied when attempted
         * updates fail due to contention among threads.  The function
         * is applied with the current value as its first argument,
         * and the given update as the second argument.
         *
         * @param x the update value
         * @param accumulatorFunction a side-effect-free function of two arguments
         * @return the previous value
         * @since 1.8
         */
        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;
        }
    
        /**
         * Atomically updates the current value with the results of
         * applying the given function to the current and given values,
         * returning the updated value. The function should be
         * side-effect-free, since it may be re-applied when attempted
         * updates fail due to contention among threads.  The function
         * is applied with the current value as its first argument,
         * and the given update as the second argument.
         *
         * @param x the update value
         * @param accumulatorFunction a side-effect-free function of two arguments
         * @return the updated value
         * @since 1.8
         */
        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;
        }
    
        /**
         * Returns the String representation of the current value.
         * @return the String representation of the current value
         */
        public String toString() {
            return String.valueOf(get());
        }
    }