转载

JDK1.8源码解析之 AtomicReference

和其他Atomic差不多，方法都一样。
可以原子更新的对象引用。
有关原子变量的属性的描述，请参见{@link java.util.concurrent.atomic}包规范。

package java.util.concurrent.atomic;
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);
    }

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

    /**
     * 将给定函数应用于当前值和给定值，以原子方式更新当前值，并返回先前的值。
     * 该函数应无副作用，因为当尝试更新由于线程间争用而失败时，可能会重新应用该函数。
     * 应用该函数时，将当前值作为其第一个参数，并将给定的update作为第二个参数。
     */
    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;
    }

    /**
     * 将给定函数应用于当前值和给定值的结果以原子方式更新当前值，并返回更新后的值。
     * 该函数应无副作用，因为当尝试更新由于线程间争用而失败时，可能会重新应用该函数。
     * 应用该函数时，将当前值作为其第一个参数，并将给定的update作为第二个参数。
     */
    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());
    }

}

复制代码

原文 https://juejin.im/post/5e949d44f265da47e90d0bbf

正文到此结束