java.util.concurrent.atomic.AtomicReference 源码

类图：

源码： 

1package java.util.concurrent.atomic;
2
3import java.util.function.UnaryOperator;
4import java.util.function.BinaryOperator;
5import sun.misc.Unsafe;
6
7//原子变量类 V:变量类型
8public class AtomicReference<V> implements java.io.Serializable {
9    private static final long serialVersionUID = -1848883965231344442L;//版本号
10
11    private static final Unsafe unsafe = Unsafe.getUnsafe();//使用sun的Unsafe完成cas指令
12
13    private static final long valueOffset;//value内存地址相对于对象内存地址的偏移量
14
15    private volatile V value;//变量类型
16
17    static {
18        try {
19            //初始化valueOffset：通过unsafe.objectFieldOffset方法获取成员属性value内存地址相对于对象内存地址的偏移量
20            valueOffset = unsafe.objectFieldOffset (AtomicReference.class.getDeclaredField("value"));
21        } catch (Exception ex) { throw new Error(ex); }
22    }
23
24    //构造方法:value为null
25    public AtomicReference() {
26    }
27
28    /**
29     * 构造方法，传入指定V值
30     */
31    public AtomicReference(V initialValue) {
32        value = initialValue;
33    }
34
35    /**
36     * 获取v值
37     */
38    public final V get() {
39        return value;
40    }
41
42    /**
43     * 设为指定值
44     */
45    public final void set(V newValue) {
46        value = newValue;
47    }
48
49    /**
50     * 最终设为指定值，但其它线程不能马上看到变化，会延时一会
51     */
52    public final void lazySet(V newValue) {
53        unsafe.putOrderedObject(this, valueOffset, newValue);
54    }
55
56    /**
57     * CAS操作，现代CPU已广泛支持，是一种原子操作；
58     * 简单地说，当期待值expect与valueOffset地址处的值相等时，设置为update值
59     */
60    public final boolean compareAndSet(V expect, V update) {
61        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
62    }
63
64    //和compareAndSet()方法相同
65    public final boolean weakCompareAndSet(V expect, V update) {
66        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
67    }
68
69    //以原子方式设置为给定值，并返回旧值
70    public final V getAndSet(V newValue) {
71        return (V)unsafe.getAndSetObject(this, valueOffset, newValue);
72    }
73
74    /**
75     * 以原子方式设置为给定值，并返回旧值
76     * updateFunction 一个参数的函数
77     */
78    public final V getAndUpdate(UnaryOperator<V> updateFunction) {
79        V prev, next;
80        do {
81            prev = get();
82            next = updateFunction.apply(prev);
83        } while (!compareAndSet(prev, next));
84        return prev;
85    }
86
87    /**
88     * 以原子方式设置为给定值，并返回新值
89     * updateFunction 一个参数的函数
90     */
91    public final V updateAndGet(UnaryOperator<V> updateFunction) {
92        V prev, next;
93        do {
94            prev = get();
95            next = updateFunction.apply(prev);
96        } while (!compareAndSet(prev, next));
97        return next;
98    }
99
100    /**
101     * 以原子方式设置为给定值，并返回旧值
102     * accumulatorFunction 两个参数的函数
103     */
104    public final V getAndAccumulate(V x, BinaryOperator<V> accumulatorFunction) {
105        V prev, next;
106        do {
107            prev = get();
108            next = accumulatorFunction.apply(prev, x);
109        } while (!compareAndSet(prev, next));
110        return prev;
111    }
112
113    /**
114     * 以原子方式设置为给定值，并返回新值
115     * accumulatorFunction 两个参数的函数
116     */
117    public final V accumulateAndGet(V x,BinaryOperator<V> accumulatorFunction) {
118        V prev, next;
119        do {
120            prev = get();
121            next = accumulatorFunction.apply(prev, x);
122        } while (!compareAndSet(prev, next));
123        return next;
124    }
125
126    //返回v类的toString()方法得到的字符串
127    public String toString() {
128        return String.valueOf(get());
129    }
130
131}