Atomic原子类总结

Atomic 原子类介绍

Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

并发包 java.util.concurrent 的原子类都存放在java.util.concurrent.atomic下,如下图所示。

根据操作的数据类型，可以将 JUC 包中的原子类分为 4 类

基本类型

使用原子的方式更新基本类型

AtomicInteger：整型原子类
AtomicLong：长整型原子类
AtomicBoolean ：布尔型原子类

数组类型

使用原子的方式更新数组里的某个元素

AtomicIntegerArray：整型数组原子类
AtomicLongArray：长整型数组原子类
AtomicReferenceArray ：引用类型数组原子类

引用类型

AtomicReference：引用类型原子类
AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来，~~也可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。~~
AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

对象的属性修改类型

AtomicIntegerFieldUpdater:原子更新整型字段的更新器
AtomicLongFieldUpdater：原子更新长整型字段的更新器
AtomicReferenceFieldUpdater：原子更新引用类型里的字段

一、基本类型原子类

使用原子的方式更新基本类型

AtomicInteger：整型原子类
AtomicLong：长整型原子类
AtomicBoolean ：布尔型原子类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicInteger 为例子来介绍。

1.1 AtomicInteger 类常用方法

1 public final int get() //获取当前的值
2 public final int getAndSet(int newValue)//获取当前的值，并设置新的值
3 public final int getAndIncrement()//获取当前的值，并自增
4 public final int getAndDecrement() //获取当前的值，并自减
5 public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
6 boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
7 public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

1.2 AtomicInteger 常见方法使用

 1 import java.util.concurrent.atomic.AtomicInteger;
 2 
 3 public class AtomicIntegerTest {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         int temvalue = 0;
 8         AtomicInteger i = new AtomicInteger(0);
 9         temvalue = i.getAndSet(3);
10         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:0;  i:3
11         temvalue = i.getAndIncrement();
12         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:3;  i:4
13         temvalue = i.getAndAdd(5);
14         System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:4;  i:9
15     }
16 }

1.3 基本数据类型原子类的优势

通过一个简单例子带大家看一下基本数据类型原子类的优势

① 多线程环境不使用原子类保证线程安全（基本数据类型）

 1 class Test {
 2     private volatile int count = 0;
 3     //若要线程安全执行执行count++，需要加锁
 4     public synchronized void increment() {
 5         count++;
 6     }
 7 
 8     public int getCount() {
 9         return count;
10     }
11 }

② 多线程环境使用原子类保证线程安全（基本数据类型）

 1 class Test2 {
 2     private AtomicInteger count = new AtomicInteger();
 3 
 4     public void increment() {
 5         count.incrementAndGet();
 6     }
 7     //使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
 8     public int getCount() {
 9         return count.get();
10     }
11 }

1.4 AtomicInteger 线程安全原理简单分析

AtomicInteger 类的部分源码

 1     // setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
 2     private static final Unsafe unsafe = Unsafe.getUnsafe();
 3     private static final long valueOffset;
 4 
 5     static {
 6         try {
 7             valueOffset = unsafe.objectFieldOffset
 8                     (AtomicInteger.class.getDeclaredField("value"));
 9         } catch (Exception ex) { throw new Error(ex); }
10     }
11 
12     private volatile int value;

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

CAS 的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址。另外 value 是一个 volatile 变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。

二、数组类型原子类

使用原子的方式更新数组里的某个元素

AtomicIntegerArray：整形数组原子类
AtomicLongArray：长整形数组原子类
AtomicReferenceArray ：引用类型数组原子类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。

2.1 AtomicIntegerArray 类常用方法

1 public final int get(int i) //获取 index=i 位置元素的值
2 public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
3 public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
4 public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
5 public final int getAndAdd(int i, int delta) //获取 index=i 位置元素的值，并加上预期的值
6 boolean compareAndSet(int i, int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
7 public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

2.2 AtomicIntegerArray 常见方法使用

 1 import java.util.concurrent.atomic.AtomicIntegerArray;
 2 
 3 public class AtomicIntegerArrayTest {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         int temvalue = 0;
 8         int[] nums = { 1, 2, 3, 4, 5, 6 };
 9         AtomicIntegerArray i = new AtomicIntegerArray(nums);
10         for (int j = 0; j < nums.length; j++) {
11             System.out.println(i.get(j));
12         }
13         temvalue = i.getAndSet(0, 2);
14         System.out.println("temvalue:" + temvalue + ";  i:" + i);
15         temvalue = i.getAndIncrement(0);
16         System.out.println("temvalue:" + temvalue + ";  i:" + i);
17         temvalue = i.getAndAdd(0, 5);
18         System.out.println("temvalue:" + temvalue + ";  i:" + i);
19     }
20 }

三、引用类型原子类

基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用引用类型原子类。

AtomicReference：引用类型原子类
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
AtomicMarkableReference ：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来，~~也可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。~~

上面三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。

3.1 AtomicReference 类常用方法

  1 package java.util.concurrent.atomic;
  2 import java.util.function.UnaryOperator;
  3 import java.util.function.BinaryOperator;
  4 import sun.misc.Unsafe;
  5 
  6 /**
  7  * An object reference that may be updated atomically. See the {@link
  8  * java.util.concurrent.atomic} package specification for description
  9  * of the properties of atomic variables.
 10  * @since 1.5
 11  * @author Doug Lea
 12  * @param  The type of object referred to by this reference
 13  */
 14 public class AtomicReference implements java.io.Serializable {
 15     private static final long serialVersionUID = -1848883965231344442L;
 16 
 17     private static final Unsafe unsafe = Unsafe.getUnsafe();
 18     private static final long valueOffset;
 19 
 20     static {
 21         try {
 22             valueOffset = unsafe.objectFieldOffset
 23                 (AtomicReference.class.getDeclaredField("value"));
 24         } catch (Exception ex) { throw new Error(ex); }
 25     }
 26 
 27     private volatile V value;
 28 
 29     /**
 30      * Creates a new AtomicReference with the given initial value.
 31      *
 32      * @param initialValue the initial value
 33      */
 34     public AtomicReference(V initialValue) {
 35         value = initialValue;
 36     }
 37 
 38     /**
 39      * Creates a new AtomicReference with null initial value.
 40      */
 41     public AtomicReference() {
 42     }
 43 
 44     /**
 45      * Gets the current value.
 46      *
 47      * @return the current value
 48      */
 49     public final V get() {
 50         return value;
 51     }
 52 
 53     /**
 54      * Sets to the given value.
 55      *
 56      * @param newValue the new value
 57      */
 58     public final void set(V newValue) {
 59         value = newValue;
 60     }
 61 
 62     /**
 63      * Eventually sets to the given value.
 64      *
 65      * @param newValue the new value
 66      * @since 1.6
 67      */
 68     public final void lazySet(V newValue) {
 69         unsafe.putOrderedObject(this, valueOffset, newValue);
 70     }
 71 
 72     /**
 73      * Atomically sets the value to the given updated value
 74      * if the current value {@code ==} the expected value.
 75      * @param expect the expected value
 76      * @param update the new value
 77      * @return {@code true} if successful. False return indicates that
 78      * the actual value was not equal to the expected value.
 79      */
 80     public final boolean compareAndSet(V expect, V update) {
 81         return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
 82     }
 83 
 84     /**
 85      * Atomically sets the value to the given updated value
 86      * if the current value {@code ==} the expected value.
 87      *
 88      * May fail
 89      * spuriously and does not provide ordering guarantees, so is
 90      * only rarely an appropriate alternative to {@code compareAndSet}.
 91      *
 92      * @param expect the expected value
 93      * @param update the new value
 94      * @return {@code true} if successful
 95      */
 96     public final boolean weakCompareAndSet(V expect, V update) {
 97         return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
 98     }
 99 
100     /**
101      * Atomically sets to the given value and returns the old value.
102      *
103      * @param newValue the new value
104      * @return the previous value
105      */
106     @SuppressWarnings("unchecked")
107     public final V getAndSet(V newValue) {
108         return (V)unsafe.getAndSetObject(this, valueOffset, newValue);
109     }
110 
111     /**
112      * Atomically updates the current value with the results of
113      * applying the given function, returning the previous value. The
114      * function should be side-effect-free, since it may be re-applied
115      * when attempted updates fail due to contention among threads.
116      *
117      * @param updateFunction a side-effect-free function
118      * @return the previous value
119      * @since 1.8
120      */
121     public final V getAndUpdate(UnaryOperator updateFunction) {
122         V prev, next;
123         do {
124             prev = get();
125             next = updateFunction.apply(prev);
126         } while (!compareAndSet(prev, next));
127         return prev;
128     }
129 
130     /**
131      * Atomically updates the current value with the results of
132      * applying the given function, returning the updated value. The
133      * function should be side-effect-free, since it may be re-applied
134      * when attempted updates fail due to contention among threads.
135      *
136      * @param updateFunction a side-effect-free function
137      * @return the updated value
138      * @since 1.8
139      */
140     public final V updateAndGet(UnaryOperator updateFunction) {
141         V prev, next;
142         do {
143             prev = get();
144             next = updateFunction.apply(prev);
145         } while (!compareAndSet(prev, next));
146         return next;
147     }
148 
149     /**
150      * Atomically updates the current value with the results of
151      * applying the given function to the current and given values,
152      * returning the previous value. The function should be
153      * side-effect-free, since it may be re-applied when attempted
154      * updates fail due to contention among threads.  The function
155      * is applied with the current value as its first argument,
156      * and the given update as the second argument.
157      *
158      * @param x the update value
159      * @param accumulatorFunction a side-effect-free function of two arguments
160      * @return the previous value
161      * @since 1.8
162      */
163     public final V getAndAccumulate(V x,
164                                     BinaryOperator accumulatorFunction) {
165         V prev, next;
166         do {
167             prev = get();
168             next = accumulatorFunction.apply(prev, x);
169         } while (!compareAndSet(prev, next));
170         return prev;
171     }
172 
173     /**
174      * Atomically updates the current value with the results of
175      * applying the given function to the current and given values,
176      * returning the updated value. The function should be
177      * side-effect-free, since it may be re-applied when attempted
178      * updates fail due to contention among threads.  The function
179      * is applied with the current value as its first argument,
180      * and the given update as the second argument.
181      *
182      * @param x the update value
183      * @param accumulatorFunction a side-effect-free function of two arguments
184      * @return the updated value
185      * @since 1.8
186      */
187     public final V accumulateAndGet(V x,
188                                     BinaryOperator accumulatorFunction) {
189         V prev, next;
190         do {
191             prev = get();
192             next = accumulatorFunction.apply(prev, x);
193         } while (!compareAndSet(prev, next));
194         return next;
195     }
196 
197     /**
198      * Returns the String representation of the current value.
199      * @return the String representation of the current value
200      */
201     public String toString() {
202         return String.valueOf(get());
203     }
204 }

3.2 AtomicReference 类使用示例

 1 import java.util.concurrent.atomic.AtomicReference;
 2 
 3 public class AtomicReferenceTest {
 4     public static void main(String[] args) {
 5         AtomicReference ar = new AtomicReference();
 6         Person person = new Person("SnailClimb", 22);
 7         ar.set(person);
 8         Person updatePerson = new Person("Daisy", 20);
 9         ar.compareAndSet(person, updatePerson);
10 
11         System.out.println(ar.get().getName());
12         System.out.println(ar.get().getAge());
13     }
14 }
15 
16 class Person {
17     private String name;
18     private int age;
19 
20     public Person(String name, int age) {
21         super();
22         this.name = name;
23         this.age = age;
24     }
25 
26     public String getName() {
27         return name;
28     }
29 
30     public void setName(String name) {
31         this.name = name;
32     }
33 
34     public int getAge() {
35         return age;
36     }
37 
38     public void setAge(int age) {
39         this.age = age;
40     }
41 }

上述代码首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。运行上面的代码后的输出结果如下：

1 Daisy
2 20

3.3 AtomicStampedReference 常用方法

 1 package com.test.java;
 2 
 3 import java.util.concurrent.atomic.AtomicStampedReference;
 4 
 5 /**
 6  * @description:
 7  * @author: luguilin
 8  * @date: 2022-03-28 17:55
 9  **/
10 
11 public class AtomicStampedReferenceDemo {
12     public static void main(String[] args) {
13         // 实例化、取当前值和 stamp 值
14         final Integer initialRef = 0, initialStamp = 0;
15         final AtomicStampedReference asr = new AtomicStampedReference<>(initialRef, initialStamp);
16         System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
17 
18         // compare and set
19         final Integer newReference = 666, newStamp = 999;
20         final boolean casResult = asr.compareAndSet(initialRef, newReference, initialStamp, newStamp);
21         System.out.println("currentValue=" + asr.getReference()
22                 + ", currentStamp=" + asr.getStamp()
23                 + ", casResult=" + casResult);
24 
25         // 获取当前的值和当前的 stamp 值
26         int[] arr = new int[1];
27         final Integer currentValue = asr.get(arr);
28         final int currentStamp = arr[0];
29         System.out.println("currentValue=" + currentValue + ", currentStamp=" + currentStamp);
30 
31         // 单独设置 stamp 值
32         final boolean attemptStampResult = asr.attemptStamp(newReference, 88);
33         System.out.println("currentValue=" + asr.getReference()
34                 + ", currentStamp=" + asr.getStamp()
35                 + ", attemptStampResult=" + attemptStampResult);
36 
37         // 重新设置当前值和 stamp 值
38         asr.set(initialRef, initialStamp);
39         System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
40 
41         // [不推荐使用，除非搞清楚注释的意思了] weak compare and set
42         // 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191]
43         // 但是注释上写着 "May fail spuriously and does not provide ordering guarantees,
44         // so is only rarely an appropriate alternative to compareAndSet."
45         // todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发
46         final boolean wCasResult = asr.weakCompareAndSet(initialRef, newReference, initialStamp, newStamp);
47         System.out.println("currentValue=" + asr.getReference()
48                 + ", currentStamp=" + asr.getStamp()
49                 + ", wCasResult=" + wCasResult);
50     }
51 }

3.4 AtomicStampedReference 类使用示例

 1 package com.test.java;
 2 
 3 import java.util.concurrent.atomic.AtomicStampedReference;
 4 
 5 /**
 6  * @description:
 7  * @author: luguilin
 8  * @date: 2022-03-28 17:55
 9  **/
10 
11 public class AtomicStampedReferenceDemo {
12     public static void main(String[] args) {
13         // 实例化、取当前值和 stamp 值
14         final Integer initialRef = 0, initialStamp = 0;
15         final AtomicStampedReference asr = new AtomicStampedReference<>(initialRef, initialStamp);
16         System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
17 
18         // compare and set
19         final Integer newReference = 666, newStamp = 999;
20         final boolean casResult = asr.compareAndSet(initialRef, newReference, initialStamp, newStamp);
21         System.out.println("currentValue=" + asr.getReference()
22                 + ", currentStamp=" + asr.getStamp()
23                 + ", casResult=" + casResult);
24 
25         // 获取当前的值和当前的 stamp 值
26         int[] arr = new int[1];
27         final Integer currentValue = asr.get(arr);
28         final int currentStamp = arr[0];
29         System.out.println("currentValue=" + currentValue + ", currentStamp=" + currentStamp);
30 
31         // 单独设置 stamp 值
32         final boolean attemptStampResult = asr.attemptStamp(newReference, 88);
33         System.out.println("currentValue=" + asr.getReference()
34                 + ", currentStamp=" + asr.getStamp()
35                 + ", attemptStampResult=" + attemptStampResult);
36 
37         // 重新设置当前值和 stamp 值
38         asr.set(initialRef, initialStamp);
39         System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
40 
41         // [不推荐使用，除非搞清楚注释的意思了] weak compare and set
42         // 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191]
43         // 但是注释上写着 "May fail spuriously and does not provide ordering guarantees,
44         // so is only rarely an appropriate alternative to compareAndSet."
45         // todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发
46         final boolean wCasResult = asr.weakCompareAndSet(initialRef, newReference, initialStamp, newStamp);
47         System.out.println("currentValue=" + asr.getReference()
48                 + ", currentStamp=" + asr.getStamp()
49                 + ", wCasResult=" + wCasResult);
50     }
51 }

输出结果如下：

1 currentValue=0, currentStamp=0
2 currentValue=666, currentStamp=999, casResult=true
3 currentValue=666, currentStamp=999
4 currentValue=666, currentStamp=88, attemptStampResult=true
5 currentValue=0, currentStamp=0
6 currentValue=666, currentStamp=999, wCasResult=true

3.5 AtomicMarkableReference 常用方法

  1 package java.util.concurrent.atomic;
  2 
  3 /**
  4  * An {@code AtomicMarkableReference} maintains an object reference
  5  * along with a mark bit, that can be updated atomically.
  6  *
  7  * Implementation note: This implementation maintains markable
  8  * references by creating internal objects representing "boxed"
  9  * [reference, boolean] pairs.
 10  *
 11  * @since 1.5
 12  * @author Doug Lea
 13  * @param  The type of object referred to by this reference
 14  */
 15 public class AtomicMarkableReference {
 16 
 17     private static class Pair {
 18         final T reference;
 19         final boolean mark;
 20         private Pair(T reference, boolean mark) {
 21             this.reference = reference;
 22             this.mark = mark;
 23         }
 24         static  Pair of(T reference, boolean mark) {
 25             return new Pair(reference, mark);
 26         }
 27     }
 28 
 29     private volatile Pair pair;
 30 
 31     /**
 32      * Creates a new {@code AtomicMarkableReference} with the given
 33      * initial values.
 34      *
 35      * @param initialRef the initial reference
 36      * @param initialMark the initial mark
 37      */
 38     public AtomicMarkableReference(V initialRef, boolean initialMark) {
 39         pair = Pair.of(initialRef, initialMark);
 40     }
 41 
 42     /**
 43      * Returns the current value of the reference.
 44      *
 45      * @return the current value of the reference
 46      */
 47     public V getReference() {
 48         return pair.reference;
 49     }
 50 
 51     /**
 52      * Returns the current value of the mark.
 53      *
 54      * @return the current value of the mark
 55      */
 56     public boolean isMarked() {
 57         return pair.mark;
 58     }
 59 
 60     /**
 61      * Returns the current values of both the reference and the mark.
 62      * Typical usage is {@code boolean[1] holder; ref = v.get(holder); }.
 63      *
 64      * @param markHolder an array of size of at least one. On return,
 65      * {@code markholder[0]} will hold the value of the mark.
 66      * @return the current value of the reference
 67      */
 68     public V get(boolean[] markHolder) {
 69         Pair pair = this.pair;
 70         markHolder[0] = pair.mark;
 71         return pair.reference;
 72     }
 73 
 74     /**
 75      * Atomically sets the value of both the reference and mark
 76      * to the given update values if the
 77      * current reference is {@code ==} to the expected reference
 78      * and the current mark is equal to the expected mark.
 79      *
 80      * 
May fail
 81      * spuriously and does not provide ordering guarantees, so is
 82      * only rarely an appropriate alternative to {@code compareAndSet}.
 83      *
 84      * @param expectedReference the expected value of the reference
 85      * @param newReference the new value for the reference
 86      * @param expectedMark the expected value of the mark
 87      * @param newMark the new value for the mark
 88      * @return {@code true} if successful
 89      */
 90     public boolean weakCompareAndSet(V       expectedReference,
 91                                      V       newReference,
 92                                      boolean expectedMark,
 93                                      boolean newMark) {
 94         return compareAndSet(expectedReference, newReference,
 95                              expectedMark, newMark);
 96     }
 97 
 98     /**
 99      * Atomically sets the value of both the reference and mark
100      * to the given update values if the
101      * current reference is {@code ==} to the expected reference
102      * and the current mark is equal to the expected mark.
103      *
104      * @param expectedReference the expected value of the reference
105      * @param newReference the new value for the reference
106      * @param expectedMark the expected value of the mark
107      * @param newMark the new value for the mark
108      * @return {@code true} if successful
109      */
110     public boolean compareAndSet(V       expectedReference,
111                                  V       newReference,
112                                  boolean expectedMark,
113                                  boolean newMark) {
114         Pair current = pair;
115         return
116             expectedReference == current.reference &&
117             expectedMark == current.mark &&
118             ((newReference == current.reference &&
119               newMark == current.mark) ||
120              casPair(current, Pair.of(newReference, newMark)));
121     }
122 
123     /**
124      * Unconditionally sets the value of both the reference and mark.
125      *
126      * @param newReference the new value for the reference
127      * @param newMark the new value for the mark
128      */
129     public void set(V newReference, boolean newMark) {
130         Pair current = pair;
131         if (newReference != current.reference || newMark != current.mark)
132             this.pair = Pair.of(newReference, newMark);
133     }
134 
135     /**
136      * Atomically sets the value of the mark to the given update value
137      * if the current reference is {@code ==} to the expected
138      * reference.  Any given invocation of this operation may fail
139      * (return {@code false}) spuriously, but repeated invocation
140      * when the current value holds the expected value and no other
141      * thread is also attempting to set the value will eventually
142      * succeed.
143      *
144      * @param expectedReference the expected value of the reference
145      * @param newMark the new value for the mark
146      * @return {@code true} if successful
147      */
148     public boolean attemptMark(V expectedReference, boolean newMark) {
149         Pair current = pair;
150         return
151             expectedReference == current.reference &&
152             (newMark == current.mark ||
153              casPair(current, Pair.of(expectedReference, newMark)));
154     }
155 
156     // Unsafe mechanics
157 
158     private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
159     private static final long pairOffset =
160         objectFieldOffset(UNSAFE, "pair", AtomicMarkableReference.class);
161 
162     private boolean casPair(Pair cmp, Pair val) {
163         return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
164     }
165 
166     static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
167                                   String field, Class<?> klazz) {
168         try {
169             return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
170         } catch (NoSuchFieldException e) {
171             // Convert Exception to corresponding Error
172             NoSuchFieldError error = new NoSuchFieldError(field);
173             error.initCause(e);
174             throw error;
175         }
176     }
177 }

3.6 AtomicMarkableReference 类使用示例

 1 import java.util.concurrent.atomic.AtomicMarkableReference;
 2 
 3 public class AtomicMarkableReferenceDemo {
 4     public static void main(String[] args) {
 5         // 实例化、取当前值和 mark 值
 6         final Boolean initialRef = null, initialMark = false;
 7         final AtomicMarkableReference amr = new AtomicMarkableReference<>(initialRef, initialMark);
 8         System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked());
 9 
10         // compare and set
11         final Boolean newReference1 = true, newMark1 = true;
12         final boolean casResult = amr.compareAndSet(initialRef, newReference1, initialMark, newMark1);
13         System.out.println("currentValue=" + amr.getReference()
14                 + ", currentMark=" + amr.isMarked()
15                 + ", casResult=" + casResult);
16 
17         // 获取当前的值和当前的 mark 值
18         boolean[] arr = new boolean[1];
19         final Boolean currentValue = amr.get(arr);
20         final boolean currentMark = arr[0];
21         System.out.println("currentValue=" + currentValue + ", currentMark=" + currentMark);
22 
23         // 单独设置 mark 值
24         final boolean attemptMarkResult = amr.attemptMark(newReference1, false);
25         System.out.println("currentValue=" + amr.getReference()
26                 + ", currentMark=" + amr.isMarked()
27                 + ", attemptMarkResult=" + attemptMarkResult);
28 
29         // 重新设置当前值和 mark 值
30         amr.set(initialRef, initialMark);
31         System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked());
32 
33         // [不推荐使用，除非搞清楚注释的意思了] weak compare and set
34         // 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191]
35         // 但是注释上写着 "May fail spuriously and does not provide ordering guarantees,
36         // so is only rarely an appropriate alternative to compareAndSet."
37         // todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发
38         final boolean wCasResult = amr.weakCompareAndSet(initialRef, newReference1, initialMark, newMark1);
39         System.out.println("currentValue=" + amr.getReference()
40                 + ", currentMark=" + amr.isMarked()
41                 + ", wCasResult=" + wCasResult);
42     }
43 }