Java原子类之AtomicReference源码分析

简介

AtomicReference是Java并发包下提供的一个带泛型的原子引用类，相比于AtomicInteger，是对整型数据操作，AtomicReference是对引用类型进行操作的。

源码分析

主要属性

    //序列化号
    private static final long serialVersionUID = -1848883965231344442L;

    //获取Unsafe对象实例
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //获取value属性的偏移量
    private static final long valueOffset;

    //静态代码块，通过unsafe获取value属性的偏移量
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicReference.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    //引用变量value
    private volatile V value;

构造方法以及其他方法

    //使用给定的初始值创建一个新的AtomicReference
    public AtomicReference(V initialValue) {
        value = initialValue;
    }
    //空参构造函数
    public AtomicReference() {
    }
    //获取value属性
    public final V get() {
        return value;
    }
    //使用给定的newValue设定value值
    public final void set(V newValue) {
        value = newValue;
    }

    public final void lazySet(V newValue) {
        unsafe.putOrderedObject(this, valueOffset, newValue);
    }
    //常用方法CAS
    public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }

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

    /**
     * Returns the String representation of the current value.
     * @return the String representation of the current value
     */
    public String toString() {
        return String.valueOf(get());
    }

总结

AtomicReference底层是通过调用Unsafe的compareAndSwapObject()方法来保证对引用对象修改的原子性。