@
目录在 atomic 包中，有三个 Reference 相关的类：AtomicReference，AtomicStampedReference，AtomicMarkableReference。
AtomicReference 无法解决 ABA 问题，而后面的两个类特别是 AtomicStampedReference 能够很好地解决 ABA 问题。
ABA问题可以见我前面的文章 unsafe 介绍（二）与CAS
1 Stamped 和 Markable的比较
AtomicStampedReference 和 AtomicMarkableReference 都能处理 ABA 问题，区别如下：
AtomicStampedReference 内部的 Pair 类，除了包含数据的 reference，还有一个 int 型的 stamp。
AtomicMarkableReference 结构类似，除了 reference 还有一个 boolean 的 mark。
AtomicStampedReference 的版本最多和不同的 Integer 个数一样多，即 \(2^{32}\)，而 AtomicMarkableReference 的版本只有两种，很容易重复。
以下只分析 AtomicStampedReference。
public class AtomicStampedReference<V> {
private static class Pair<T> {
final T reference;
// 使用 stamp 标记
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;
...
}
public class AtomicMarkableReference<V> {
private static class Pair<T> {
final T reference;
// 使用 mark 标记
final boolean mark;
private Pair(T reference, boolean mark) {
this.reference = reference;
this.mark = mark;
}
static <T> Pair<T> of(T reference, boolean mark) {
return new Pair<T>(reference, mark);
}
}
private volatile Pair<V> pair;
}
2 介绍
正如前面所说，AtomicStampedReference 内部持有一个 Pair，而 Pair 其实包含数据 reference 和版本 stamp 的。
注意到 reference 和版本 stamp 都是 final 的，保证不可变。要修改只能调用静态的 of 生成一个新的 Pair，这保证了安全。
下面的 get 方法只返回 reference，stamp 会放在 stampHolder[0] 中。
// 初始化
public AtomicStampedReference(V initialRef, int initialStamp) {
pair = Pair.of(initialRef, initialStamp);
}
/**
* Returns the current value of the reference.
*
* @return the current value of the reference
*/
public V getReference() {
return pair.reference;
}
/**
* Returns the current value of the stamp.
*
* @return the current value of the stamp
*/
public int getStamp() {
return pair.stamp;
}
/**
* Returns the current values of both the reference and the stamp.
* Typical usage is {@code int[1] holder; ref = v.get(holder); }.
*
* @param stampHolder an array of size of at least one. On return,
* {@code stampholder[0]} will hold the value of the stamp.
* @return the current value of the reference
*/
// 将 reference 返回， stamp 放入 stampHolder[0]
public V get(int[] stampHolder) {
Pair<V> pair = this.pair;
stampHolder[0] = pair.stamp;
return pair.reference;
}
3 其他方法
下面的方法都调用 Unsafe，前文讲过，不再描述。
重点是 compareAndSet 和 attemptStamp，return 后面非常不好理解。
涉及的知识点是 && 的短路机制。如果有三个表达式 a,b,c，把它们组合成一个新的表达式 a && b && c，短路机制如下：
如果 a 为 false，结果为 false，不处理 b 和 c
如果 a 为 true，继续处理
如果 b 为 false，结果为 false，不处理 c
如果 b 为 true ，继续处理
如果 c 为 false，返回 false
如果 c 为 true ，返回 true
以 compareAndSet 为例，如果期望的 expectedReference 满足条件，才会判断期望的 expectedStamp；如果期望的 expectedStamp 满足条件，才执行第三个括号；如果没有执行到第三个括号就结束，说明期望值不管是 reference 还是 stamp 至少一个不满足条件，会返回 false。
第三个括号首先判断当前值是不是已经是新的值了，如果是，那就不用修改，返回 true即可；如果不是，则需要执行 CAS，并将 CAS 执行是否成功的情况返回。
这个做法是满足 CAS 的定义的，如果期望的值是相等的，才会尝试修改新值。只不过这里多判断了一步，如果新值和现在不一样才修改，减少开销。
attemptStamp 表示只有 expectedReference 满足条件时，才尝试比较新 stamp 或者修改，否则不会修改。
/**
* 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.
*
* <p><a href="package-summary.html#weakCompareAndSet">May fail
* spuriously and does not provide ordering guarantees</a>, so is
* only rarely an appropriate alternative to {@code compareAndSet}.
*
* @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 weakCompareAndSet(V expectedReference,
V newReference,
int expectedStamp,
int newStamp) {
return compareAndSet(expectedReference, newReference,
expectedStamp, newStamp);
}
/**
* 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<V> current = pair;
return
expectedReference == current.reference &&
expectedStamp == current.stamp &&
((newReference == current.reference &&
newStamp == current.stamp) ||
casPair(current, Pair.of(newReference, newStamp)));
}
/**
* Unconditionally sets the value of both the reference and stamp.
*
* @param newReference the new value for the reference
* @param newStamp the new value for the stamp
*/
public void set(V newReference, int newStamp) {
Pair<V> current = pair;
// 无条件修改，只要reference和stamp有一个不同就修改
if (newReference != current.reference || newStamp != current.stamp)
this.pair = Pair.of(newReference, newStamp);
}
/**
* Atomically sets the value of the stamp to the given update value
* if the current reference is {@code ==} to the expected
* reference. Any given invocation of this operation may fail
* (return {@code false}) spuriously, but repeated invocation
* when the current value holds the expected value and no other
* thread is also attempting to set the value will eventually
* succeed.
*
* @param expectedReference the expected value of the reference
* @param newStamp the new value for the stamp
* @return {@code true} if successful
*/
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);
}
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;
}
}
4 代码示例
两个线程 t1 和 t2。让 t1 先获取 stamp 后，让 t2 执行两次修改，t1 再执行一次修改，观察是否成功。
具体实现是通过 volatile boolean b 来控制前半段，在 t1 获取 stamp 前，t2 先空循环；通过在 t1 中使用 t2.join 等待 join 完成来控制后半段，将程序修改为串行执行。
最后的结果是 t2 修改失败，因为版本号已经改变了。
import java.util.concurrent.atomic.AtomicStampedReference;
public class A {
private static AtomicStampedReference<Integer> atomicStampedRef =
new AtomicStampedReference<>(1, 0);
private static volatile boolean b = false;
public static void main(String[] args){
Thread t2 = new Thread(() -> {
// 等待t1修改b后执行
// b修改前先空循环
while(!b) {}
atomicStampedRef.compareAndSet(1, 2, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
System.out.println("操作线程" + Thread.currentThread() + ",【increment】 ,值 = " + atomicStampedRef.getReference());
atomicStampedRef.compareAndSet(2, 1, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
System.out.println("操作线程" + Thread.currentThread() + ",【decrement】 ,值 = " + atomicStampedRef.getReference());
},"t2");
Thread t1 = new Thread(() -> {
System.out.println("操作线程" + Thread.currentThread() +",初始值 a = " + atomicStampedRef.getReference());
int stamp = atomicStampedRef.getStamp(); //获取当前标识
b = true;
try {
// 等待 t2 结束
t2.join();
}catch(Exception e){
e.printStackTrace();
}
boolean isCASSuccess = atomicStampedRef.compareAndSet(1,2,stamp,stamp +1); //此时expectedReference未发生改变，但是stamp已经被修改了,所以CAS失败
System.out.println("操作线程" + Thread.currentThread() +",CAS操作结果: " + isCASSuccess);
},"t1");
t1.start();
t2.start();
}
}
下面是我的公众号，Java与大数据进阶，分享 Java 与大数据笔面试干货，欢迎关注