摘要：區(qū)別在于內(nèi)部維護了一個的二元組。操作內(nèi)部維護一個靜態(tài)內(nèi)部類表示引用對象表示時間戳版本號，型通過增加了版本號的操作，可以避免問題，即更新始終是遞增的，不會出現(xiàn)往復(fù)。

這三個都是自JDK1.5開始加入到java.util.concurrent.atomic下面的。他們都可以在lock-free的情況下以原子的方式更新對象引用。

區(qū)別在于：AtomicStampedReference內(nèi)部維護了一個[reference, integer] pairs的二元組。AtomicMarkableReference 內(nèi)部維護了一個[reference, boolean] pairs的二元組。

以下部分源碼片段摘自JDK1.8（保留了注釋）:

AtomicReference

public class AtomicReference implements java.io.Serializable {
    private static final long serialVersionUID = -1848883965231344442L;

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    //class初始化時執(zhí)行
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicReference.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //通過volatile關(guān)鍵字保證value值的可見性。
    private volatile V value;
    
    public AtomicReference(V initialValue) {
        value = initialValue;
    }
    
    public AtomicReference() {
    }
    
    //CAS操作
    /**
     * 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);
    }
}

AtomicStampedReference

public class AtomicStampedReference {
    //內(nèi)部維護一個靜態(tài)內(nèi)部類
    //reference表示引用對象
    //stamp表示時間戳（版本號），int型
    private static class Pair {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static  Pair of(T reference, int stamp) {
            return new Pair(reference, stamp);
        }
    }

    private volatile Pair pair;

    /**
     * Creates a new {@code AtomicStampedReference} with the given
     * initial values.
     *
     * @param initialRef the initial reference
     * @param initialStamp the initial stamp
     */
    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
    
    /**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedStamp the expected value of the stamp
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair current = pair;
        //通過增加了stamp（版本號）的CAS操作，可以避免ABA問題，即更新始終是遞增的，不會出現(xiàn)往復(fù)。
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }
    
    private boolean casPair(Pair cmp, Pair val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }
}

AtomicMarkableReference

public class AtomicMarkableReference {
    //這里幾乎和AtomicStampedReference相同，只是從 final int stamp 變成了 final boolean mark
    private static class Pair {
        final T reference;
        final boolean mark;
        private Pair(T reference, boolean mark) {
            this.reference = reference;
            this.mark = mark;
        }
        static  Pair of(T reference, boolean mark) {
            return new Pair(reference, mark);
        }
    }

    private volatile Pair pair;

    /**
     * Creates a new {@code AtomicMarkableReference} with the given
     * initial values.
     *
     * @param initialRef the initial reference
     * @param initialMark the initial mark
     */
    public AtomicMarkableReference(V initialRef, boolean initialMark) {
        pair = Pair.of(initialRef, initialMark);
    }
}