Java原子类之AtomicStampedReference源码分析
一、简介
AtomicStampedReference
是java
并发包下提供的一个原子类,它能解决其它原子类无法解决的ABA
问题。
二、ABA
2.1 ABA问题
ABA
问题发生在多线程环境中,当某线程连续读取同一块内存地址两次,两次得到的值一样,它简单地认为“此内存地址的值并没有被修改过”,然而,同时可能存在另一个线程在这两次读取之间把这个内存地址的值从A修改成了B又修改回了A,这时还简单地认为“没有修改过”显然是错误的。
比如,两个线程按下面的顺序执行:
(1)线程1读取内存位置X的值为A;
(2)线程1阻塞了;
(3)线程2读取内存位置X的值为A;
(4)线程2修改内存位置X的值为B;
(5)线程2修改又内存位置X的值为A;
(6)线程1恢复,继续执行,比较发现还是A把内存位置X的值设置为C;
可以看到,针对线程1来说,第一次的A和第二次的A实际上并不是同一个A。
ABA
问题通常发生在无锁结构中,用代码来表示上面的过程大概就是这样:
public class ABATest {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(1);
new Thread(()->{
int value = atomicInteger.get();
System.out.println("thread 1 read value: " + value);
// 阻塞1s
LockSupport.parkNanos(1000000000L);
if (atomicInteger.compareAndSet(value, 3)) {
System.out.println("thread 1 update from " + value + " to 3");
} else {
System.out.println("thread 1 update fail!");
}
}).start();
new Thread(()->{
int value = atomicInteger.get();
System.out.println("thread 2 read value: " + value);
if (atomicInteger.compareAndSet(value, 2)) {
System.out.println("thread 2 update from " + value + " to 2");
// do sth
value = atomicInteger.get();
System.out.println("thread 2 read value: " + value);
if (atomicInteger.compareAndSet(value, 1)) {
System.out.println("thread 2 update from " + value + " to 1");
}
}
}).start();
}
}
打印结果为:
thread 1 read value: 1
thread 2 read value: 1
thread 2 update from 1 to 2
thread 2 read value: 2
thread 2 update from 2 to 1
thread 1 update from 1 to 3
2.2 ABA的危害
为了更好地理解ABA
的危害,我们还是来看一个现实点的例子。
假设我们有一个无锁的栈结构,如下:
public class ABATest {
static class Stack {
// 将top放在原子类中
private AtomicReference<Node> top = new AtomicReference<>();
// 栈中节点信息
static class Node {
int value;
Node next;
public Node(int value) {
this.value = value;
}
}
// 出栈操作
public Node pop() {
for (;;) {
// 获取栈顶节点
Node t = top.get();
if (t == null) {
return null;
}
// 栈顶下一个节点
Node next = t.next;
// CAS更新top指向其next节点
if (top.compareAndSet(t, next)) {
// 把栈顶元素弹出,应该把next清空防止外面直接操作栈
t.next = null;
return t;
}
}
}
// 入栈操作
public void push(Node node) {
for (;;) {
// 获取栈顶节点
Node next = top.get();
// 设置栈顶节点为新节点的next节点
node.next = next;
// CAS更新top指向新节点
if (top.compareAndSet(next, node)) {
return;
}
}
}
}
}
乍一看,这段程序似乎没有什么问题,然而试想以下情形。
假如,我们初始化栈结构为top->1->2->3,然后有两个线程分别做如下操作:
(1)线程1执行pop()
出栈操作,但是执行到if (top.compareAndSet(t, next)) {
这行之前暂停了,所以此时节点1并未出栈;
(2)线程2执行pop()
出栈操作弹出节点1,此时栈变为top->2->3
;
(3)线程2执行pop()
出栈操作弹出节点2,此时栈变为top->3
;
(4)线程2执行push()
入栈操作添加节点1,此时栈变为top->1->3
;
(5)线程1恢复执行,比较节点1的引用并没有改变,执行CAS
成功,此时栈变为top->2
;
What?点解变成top->2了?不是应该变成top->3吗?
那是因为线程1在第一步保存的next是节点2,所以它执行CAS成功后top节点就指向了节点2了。
测试代码如下:
private static void testStack() {
// 初始化栈为 top->1->2->3
Stack stack = new Stack();
stack.push(new Stack.Node(3));
stack.push(new Stack.Node(2));
stack.push(new Stack.Node(1));
new Thread(()->{
// 线程1出栈一个元素
stack.pop();
}).start();
new Thread(()->{
// 线程2出栈两个元素
Stack.Node A = stack.pop();
Stack.Node B = stack.pop();
// 线程2又把A入栈了
stack.push(A);
}).start();
}
public static void main(String[] args) {
testStack();
}
在Stack
的pop()
方法的if (top.compareAndSet(t, next)) {
处打个断点,线程1运行到这里时阻塞它的执行,让线程2执行完,再执行线程1这句,这句执行完可以看到栈的top
对象中只有2这个节点了。
记得打断点的时候一定要打Thread断点,在
IDEA
中是右击选择Suspend
为Thread
。
2.3 ABA的解决方法
ABA
的危害我们清楚了,那么怎么解决ABA呢?
大概有以下几种方式:
- 版本号
比如,上面的栈结构增加一个版本号用于控制,每次CAS
的同时检查版本号有没有变过。
还有一些数据结构喜欢使用高位存储一个邮戳来保证CAS
的安全。
- 不重复使用节点的引用
比如,上面的栈结构在线程2执行push()
入栈操作的时候新建一个节点传入,而不是复用节点1的引用;
- 直接操作元素而不是节点
比如,上面的栈结构push()
方法不应该传入一个节点(Node
),而是传入元素值(int
的value
)。
三、源码分析
3.1 内部类
private static class Pair<T> {
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);
}
}
将元素值和版本号绑定在一起,存储在Pair
的reference
和stamp
(邮票、戳的意思)中。
3.2 属性
private volatile Pair<V> pair;
private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
private static final long pairOffset =
objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);
声明一个Pair
类型的变量并使用Unsafe
获取其偏移量,存储到pairOffset
中。
3.3 构造方法
public AtomicStampedReference(V initialRef, int initialStamp) {
pair = Pair.of(initialRef, initialStamp);
}
构造方法需要传入初始值及初始版本号。
可以看到,除了传入一个初始的引用变量initialRef
外,还有一个initialStamp
变量,initialStamp
其实就是版本号(或者说时间戳),用来唯一标识引用变量。在构造器内部,实例化了一个Pair
对象,Pair
对象记录了对象引用和时间戳信息,采用int
作为时间戳,实际使用的时候,要保证时间戳唯一(一般做成自增的),如果时间戳如果重复,还会出现ABA
的问题。
AtomicStampedReference
的所有方法,其实就是Unsafe
类针对这个Pair
对象的操作。
和AtomicReference
相比,AtomicStampedReference
中的每个引用变量都带上了pair.stamp
这个版本号,这样就可以解决CAS
中的ABA
问题了。
3.4 compareAndSet()方法
//如果当前引用等于预期值并且当前版本戳等于预期版本戳, 将更新新的引用和新的版本戳到内存
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) ||
// 构造新的Pair对象并CAS更新
casPair(current, Pair.of(newReference, newStamp)));
}
private boolean casPair(Pair<V> cmp, Pair<V> val) {
// 调用Unsafe的compareAndSwapObject()方法CAS更新pair的引用为新引用
return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}
(1)如果元素值和版本号都没有变化,并且和新的也相同,返回true
;
(2)如果元素值和版本号都没有变化,并且和新的不完全相同,就构造一个新的Pair
对象并执行CAS
更新pair
。
可以看到,java
中的实现跟我们上面讲的ABA
的解决方法是一致的。
首先,使用版本号控制;
其次,不重复使用节点(Pair
)的引用,每次都新建一个新的Pair
来作为CAS
比较的对象,而不是复用旧的;
最后,外部传入元素值及版本号,而不是节点(Pair
)的引用。
3.5 全部源码
public class AtomicStampedReference<V> {
private static class Pair<T> {
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;
//构造方法, 传入引用和戳
public AtomicStampedReference(V initialRef, int initialStamp) {
pair = Pair.of(initialRef, initialStamp);
}
//返回引用
public V getReference() {
return pair.reference;
}
//返回版本戳
public int getStamp() {
return pair.stamp;
}
public V get(int[] stampHolder) {
Pair<V> pair = this.pair;
stampHolder[0] = pair.stamp;
return pair.reference;
}
public boolean weakCompareAndSet(V expectedReference,
V newReference,
int expectedStamp,
int newStamp) {
return compareAndSet(expectedReference, newReference,
expectedStamp, newStamp);
}
//如果当前引用 等于 预期值并且 当前版本戳等于预期版本戳, 将更新新的引用和新的版本戳到内存
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)));
}
//设置当前引用的新引用和版本戳
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);
}
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;
}
}
}
四、案例
让我们来使用AtomicStampedReference
解决开篇那个AtomicInteger
带来的ABA
问题。
public class ABATest {
public static void main(String[] args) {
testStamp();
}
private static void testStamp() {
// 创建AtomicStampedReference对象,持有Integer对象的引用,初始为1,版本为1
AtomicStampedReference<Integer> asr = new AtomicStampedReference<>(1, 1);
new Thread(() -> {
int[] stampHolder = new int[1];
int value = asr.get(stampHolder);
int stamp = stampHolder[0];
System.out.println("thread 1 read value: " + value + ", stamp: " + stamp);
// 阻塞1s
LockSupport.parkNanos(1000000000L);
if (asr.compareAndSet(value, 3, stamp, stamp + 1)) {
System.out.println("thread 1 update from " + value + " to 3");
} else {
System.out.println("thread 1 update fail!");
}
}).start();
new Thread(() -> {
int[] stampHolder = new int[1];
// 调用get方法获取引用对象和对应的版本号
int value = asr.get(stampHolder);
int stamp = stampHolder[0];
System.out.println("thread 2 read value: " + value + ", stamp: " + stamp);
if (asr.compareAndSet(value, 2, stamp, stamp + 1)) {
System.out.println("thread 2 update from " + value + " to 2");
// do sth
value = asr.get(stampHolder);
// stampHolder[0]保存版本号
stamp = stampHolder[0];
System.out.println("thread 2 read value: " + value + ", stamp: " + stamp);
//尝试以CAS方式更新引用对象,并将版本号+1
if (asr.compareAndSet(value, 1, stamp, stamp + 1)) {
System.out.println("thread 2 update from " + value + " to 1");
}
}
}).start();
}
}
运行结果为:
thread 1 read value: 1, stamp: 1
thread 2 read value: 1, stamp: 1
thread 2 update from 1 to 2
thread 2 read value: 2, stamp: 2
thread 2 update from 2 to 1
thread 1 update fail!
可以看到线程1最后更新1到3时失败了,因为这时版本号也变了,成功解决了ABA
的问题。
上述模板就是AtomicStampedReference
的一般使用方式,注意下compareAndSet方法,AtomicStampedReference
内部保存了一个pair
对象,该方法的逻辑如下:
如果AtomicStampedReference
内部pair
的引用变量、时间戳与入参expectedReference
、expectedStamp
都一样,说明期间没有其它线程修改过AtomicStampedReference
,可以进行修改。此时,会创建一个新的Pair
对象(casPair
方法,因为Pair
是Immutable
类)。
但这里有段优化逻辑,就是如果newReference == current.reference && newStamp == current.stamp
,说明用户修改的新值和AtomicStampedReference
中目前持有的值完全一致,那么其实不需要修改,直接返回true
即可。
五、总结
- 在多线程环境下使用无锁结构要注意
ABA
问题; ABA
的解决一般使用版本号来控制,并保证数据结构使用元素值来传递,且每次添加元素都新建节点承载元素值;AtomicStampedReference
内部使用Pair
来存储元素值及其版本号;
六、拓展
6.1 java中还有哪些类可以解决ABA的问题?
AtomicMarkableReference
,它不是维护一个版本号,而是维护一个boolean
类型的标记,标记值有修改,了解一下。
6.2 实际工作中遇到过ABA问题吗?
笔者还真遇到过,以前做棋牌游戏的时候,ABCD四个玩家,A玩家出了一张牌,然后他这个请求迟迟没到服务器,也就是超时了,服务器就帮他自动出了一张牌。
然后,转了一圈,又轮到A玩家出牌了,说巧不巧,正好这时之前那个请求到了服务器,服务器检测到现在正好是A出牌,而且请求的也是出牌,就把这张牌打出去了。
然后呢,A玩家的牌就不对了。
最后,我们是通过给每个请求增加一个序列号来处理的,检测到过期的序列号请求直接抛弃掉。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器