深入理解并发之AtomicReference类

深入理解并发之AtomicReference类

​ 上篇文章主要分享了基本封装类型的原子类，例如 AtomicInteger，AtomicBoolean，AtomicLong等。那么对象的原子操作如何实现？那本文就将从AtomicReference 类讲述对象原子类如何操作。

1: AtomicReference 源码

public class AtomicReference<V> implements java.io.Serializable {
 
    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;

    /**
     * 有参构造
     */
    public AtomicReference(V initialValue) {
        value = initialValue;
    }

    /**
     * 无参构造
     */
    public AtomicReference() {
    }

    /**
     *  获取AtomicReference的当前对象引用值
     */
    public final V get() {
        return value;
    }

    /**
     * 设置AtomicReference最新的对象引用值，该新值的更新对其他线程立即可见
     */
    public final void set(V newValue) {
        value = newValue;
    }


    /**
     * 原子性地更新AtomicReference内部的value值，其中expect代表当前AtomicReference的value值，update		*  则是需要设置的新引用值。该方法会返回一个boolean的结果，当expect和AtomicReference的当前值不相        *  等时，修改会失败，返回值为false，若修改成功则会返回true.
     */
    public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }


    /**
     * 原子性地更新AtomicReference内部的value值，并且返回AtomicReference的旧值
     */
    @SuppressWarnings("unchecked")
    public final V getAndSet(V newValue) {
        return (V)unsafe.getAndSetObject(this, valueOffset, newValue);
    }

    /**
     *原子性地更新value值，并且返回AtomicReference的旧值，该方法需要传入一个Function接口
     */
    public final V getAndUpdate(UnaryOperator<V> updateFunction) {
        V prev, next;
        do {
            prev = get();
            next = updateFunction.apply(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    /**
     * 原子性地更新value值，并且返回AtomicReference更新后的新值，该方法需要传入一个Function接口
     */
    public final V updateAndGet(UnaryOperator<V> updateFunction) {
        V prev, next;
        do {
            prev = get();
            next = updateFunction.apply(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

    /**
     * 原子性地更新value值，并且返回AtomicReference更新前的旧值。该方法需要传入两个参数，
     *	第一个是更新后的新值，
     *	第二个是BinaryOperator接口
     */
    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;
    }

    /**
     * 原子性地更新value值，并且返回AtomicReference更新后的值。该方法需要传入两个参数，
     *	第一个是更新的新值，
     *	第二个是BinaryOperator接口。
     */
    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;
    }
}

2: 基本用法

假设，我们现在要对用户进行银行卡转账操作并保证转账的安全性。