AtomicStampedReference源码分析

public class Snippet {
    //修改的是AtomicStampedReference对象里面的值了。
    public static void main(String[] args) {
            //现在AtomicStampedReference里面的pair是{aaa,1},
            AtomicStampedReference<String> reference = new AtomicStampedReference<String>("aaa",);
            System.out.println(reference.compareAndSet("aaa","bbb",reference.getStamp(),reference.getStamp()+));
            //现在AtomicStampedReference里面的pair是{bbb,2},
            System.out.println("reference.getReference() = " + reference.getReference());

            //只是修改版本，不修改值，现在AtomicStampedReference里面的pair是{bbb,3},
            boolean b = reference.attemptStamp("bbb", reference.getStamp() + );
            System.out.println("b: "+b);
            System.out.println("reference.getStamp() = "+reference.getStamp());

            boolean c = reference.weakCompareAndSet("bbb","ccc",, reference.getStamp()+);
            System.out.println("reference.getReference() = "+reference.getReference());
            System.out.println("c = " + c);//现在AtomicStampedReference里面的pair是{bbb,3},
    }
}

public class AtomicStampedReference<V> {

    private static class Pair<T> {//将值和版本号封装为一个Pair，比较就是比较这个Pair。
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;//多个线程同时修改这个pair要可见。比如：一直自加到100

    public AtomicStampedReference(V initialRef, int initialStamp) {//构造AtomicStampedReference时候把要多线程修改的
    //值封装成pair
        pair = Pair.of(initialRef, initialStamp);
    }

    public V getReference() {//获取准备通过AtomicStampedReference来改变的值。
        return pair.reference;
    }

    public int getStamp() {//获取准备通过AtomicStampedReference来改变的值的版本号。
        return pair.stamp;
    }

    public V get(int[] stampHolder) {
        Pair<V> pair = this.pair;
        stampHolder[] = pair.stamp;
        return pair.reference;
    }

    public boolean weakCompareAndSet(V   expectedReference,
                                     V   newReference,
                                     int expectedStamp,
                                     int newStamp) {
        return compareAndSet(expectedReference, newReference,
                             expectedStamp, newStamp);
    }
//旧值修改为新值。有3个：现在值2个，期望现在值2个，新值2个。
//期望值和现在值2个相等，前提下，新值和现在值2个都相等不改变，否则该变。
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            //现在值和期望现在值里面2个一样直接返回false不需要更新。
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            //现在值和期望现在值里面2个一样需要更新
            //新值和现在值2个都一样返回false不需要更新
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
              //现在值和期望现在值里面2个一样,并且新值和现在值有一个不一样，需要更新。
             casPair(current, Pair.of(newReference, newStamp)));//改变旧的pair为新的pair，新的pair要重新构造一个新的。
    }

    public void set(V newReference, int newStamp) {
        Pair<V> current = pair;
        if (newReference != current.reference || newStamp != current.stamp)
            this.pair = Pair.of(newReference, newStamp);
    }

    public boolean attemptStamp(V expectedReference, int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            (newStamp == current.stamp ||
             casPair(current, Pair.of(expectedReference, newStamp)));
    }

    // Unsafe mechanics

    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
    private static final long pairOffset =
        objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);

    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);//改变里面的pair从cmp到val
    }

    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
                                  String field, Class<?> klazz) {
        try {
            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
        } catch (NoSuchFieldException e) {
            // Convert Exception to corresponding Error
            NoSuchFieldError error = new NoSuchFieldError(field);
            error.initCause(e);
            throw error;
        }
    }
}