特定的无锁场景问题(如无锁栈)解决：AtomicStampedReference

最新推荐文章于 2024-08-25 09:31:44 发布
最新推荐文章于 2024-08-25 09:31:44 发布
阅读量510 收藏 1
点赞数
分类专栏： 多线程 文章标签： AtomicStampedReference 无锁CAS 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justinzengTM/article/details/90175796
版权
本文探讨了无锁比较交换在特定场景下存在的问题，例如无锁栈操作可能导致的数据不一致。通过分析多线程操作栈的例子，展示了忽略过程变化可能引发的错误。为了解决这个问题，文章介绍了Java的AtomicStampedReference，它增加了版本号或时间戳，确保在值和时间戳都匹配的情况下进行修改，避免了因其他线程修改导致的错误。
摘要由CSDN通过智能技术生成

虽然无锁比较交换让代码看起来比直接加锁复杂一点点，但是无锁比较交换能提供更高的效率，没错，且不存在死锁问题，但是无锁操作不是所有场景下都是安全的。先用最简单直白的概括回顾下CAS，有三个参数V，E，N，只有当“预期值”E和对象V的值相等时，才把V的值更新为“更新值”V。可以看到，是否修改V的值，取决于V的值和E是否相等，如果不相等，那么程序就会重新读取V的值，直到V的值与E相等后，才做修改操作(当然也可以放弃等待)，这样做看似没什么问题，但是在某些特定场景下，和实际应用中，是存在一些问题的，因为在多线程环境下，一个对象可能会被多个线程访问，修改，且修改的值是不确定的，所以无锁比较交换操作下可能出现的问题是以下这个情景。

使用AtomicReference的无锁比较交换，假设对象V的初始值为0，线程T1要对对象V做修改操作，首先取得V的值为0保存到变量tmp中后，在做修改操作V.compareAndSet(tmp, tmp+1)；之前，线程T1被阻塞了(可能cpu调度或时间片问题)，此时另外的线程T2和T3也对这个对象V做修改操作，T2线程把V修改为1，接着T3线程把V修改回0，最后当T1线程唤醒继续执行修改操作，发现tmp的值为0，仍然为预期值，接着就对对象V写入新值。

上述这个场景我们可以发现，T1线程做compareAndSet()方法时，拿到的tmp其实是个新值，只是这个新值与旧值相等了，所以T1线程“以为”对象V没有做过修改，符和预期值。虽然从结果上看，这样做好像没什么问题，对于T1线程来说，它的任务就是当对象V的值等于期望值tmp(也就是为0)时，把它修改为1嘛。在这样的场景下可能是没问题，例如，如果你要做累加或累减操作，这样无锁比较交换是不会出错的，哪怕过程中有其他线程做过修改，只要对象的值不符合期望值，当前线程都不会对对象的值做修改，而是一直重复读取对象V，直到与期望值相等，或是放弃，这种做法有一个问题，就是只看结果，而忽略了过程的改变。

在某些特定场景中，忽略过程是会出问题的，例如我们看一个多线程操作同一个栈的例子：

package atomicstampedreference;

import java.util.concurrent.atomic.AtomicReference;

public class Stack {
	private AtomicReference<Node> stackTop = new AtomicReference<>();
	
	//栈的存储结构
	static class Node {
		int value;
		Node next; //指向下一个结点
		
		//构造函数初始化
		public Node(int value) {
			this.value = value;
		}
	}
	
	//无锁CAS入栈
	public void push(Node newNode) {
		//无锁CAS操作,所以用一个死循环
		for(;;) {
			Node tmpTop = stackTop.get(); //首先获得栈顶结点
			newNode.next = tmpTop; //新栈顶结点的next指向旧的栈顶结点
			
			//更新新的栈顶结点
			if(stackTop.compareAndSet(tmpTop, newNode)) {
				return;
			}
		}
	}
	
	//无锁CAS出栈
	public Node pop() {
		//同样死循环
		for(;;) {
			Node tmpTop = stackTop.get(); //获得栈顶结点
			//特殊情况判断
			if(tmpTop == null) {
				System.out.println("错误!栈顶元素为空.");
				return null;
			}
			Node newTop = tmpTop.next; //保存栈中的新栈顶结点
			
			//更新栈顶结点
			if(stackTop.compareAndSet(tmpTop, newTop)) {
				tmpTop.next = null;
				return tmpTop;
			}
		}
	}
	
	//输出当前栈
	public void printStack() {
		
	}
}

package atomicstampedreference;
 
public class UnSafeStack {

	public static void main(String[] args) {
		Stack stack = new Stack(); //实例化栈
		Stack.Node node1 = new Stack.Node(1);
		Stack.Node node2= new Stack.Node(2);
		Stack.Node node3= new Stack.Node(3);
		//三个结点入栈
		stack.push(node3);
		stack.push(node2);
		stack.push(node1);
		
		Thread T1 = new Thread(new Runnable() {
			@Override
			public void run() {
				Stack.Node tmp = stack.pop();
			}
		});
		
		Thread T2 = new Thread(new Runnable() {
			@Override
			public void run() {
				Stack.Node tmp1 = stack.pop();
				Stack.Node tmp2 = stack.pop();
				stack.push(tmp1);
			}
		});
		
		T1.start();
		T2.start();
	}

}

我们往栈中压入三个结点，值分别为int型1，2，3。在线程T1中做出栈操作中，取得当前栈顶元素后，先让线程T1阻塞，模拟cpu调度。此时另一个线程启动，做两次出栈操作和一次入栈操作，那么结点1和2都被出栈，栈中只剩结点3，然后在把结点1入栈，之后当前栈变成1->3，线程完成任务。然后我们让线程T1唤醒，继续它的任务，此时线程T1执行compareAndSet()方法，虽然方法重新获取一遍tmpTop的值，但发现发现栈顶元素的value还是等于1，与期望值相等，所以把结点1出栈，之后就出问题了，compareAndSet()方法操作是更新栈顶元素，此时线程T1会把栈顶元素也就是tmpTop更新为结点2。这与线程2修改后的栈状态冲突，可能会发生意想不到的灾难。

在实际应用中，哪怕不涉及什么复杂的算法，也会出现足以让你损失巨大的问题，来看这样一个例子：假如通讯服务商做回馈用户活动，在本月为所有当前剩余流量低于50M的用户免费赠送100M的流量，每个用户本月只能赠送一次。设计这样的程序很容易，只要扫描所有用户，查询当前用户的剩余流量，低于50M就赠送100M，可是如果在多线程下，会出现这样的情况，假设在给一位剩余流量低于50M的用户赠送流量时，该用户同时也在使用流量，且使用的流量大于或等于100M，这就使得赠送流量后，用户剩余流量等于甚至低于赠送前的流量，使得赠送线程误以为这个用户没用赠送过流量，然后再次给这个用户赠送100M。表述的不太好，来看看代码是怎么回事：

package atomicstampedreference;

import java.util.concurrent.atomic.AtomicReference;

public class UnSafeAtomicReference {

	static AtomicReference<Integer> flow = new AtomicReference<Integer>();

	public static void main(String[] args) {
		flow.set(45); //初始流量为45M
		
		//模拟服务提供商赠送
		for(int i=0; i<20; i++) {
			Thread T1 = new Thread(new Runnable() {
				@Override
				public void run() {
					while(true) {
						for(;;) {
							Integer f = flow.get();
							if(f<50) {
								System.out.println("剩余流量小于50M,赠送100M....");
								if(flow.compareAndSet(f, f+100)) {
									System.out.println("流量充值成功!当前流量剩余:"+flow.get());
									break;
								}
							} else {
								//System.out.println("剩余流量大于50M,不参与赠送活动.");
								break;
							}
						}
					}	
				}
			});
			T1.start();
		}
		
		//模拟消耗流量
		for(int i=0; i<20; i++) {
			Thread T2 = new Thread(new Runnable() {
				@Override
				public void run() {
					while(true) {
						Integer f = flow.get();
						if(f>50) {
							System.out.println("剩余流量大于50M,使用流量....");
							if(flow.compareAndSet(f, f-25)) {
								System.out.println("流量使用25M,当前流量剩余:"+flow.get());
								break;
							}
						} else {
							System.out.println("剩余流量不足50M,无法使用.");
							break;
						}
						try {
							Thread.sleep(200);
						} catch(InterruptedException e) {
							e.printStackTrace();
						}
					}	
				}
			});
			T2.start();
		}
		
	}

}

初始化时假设用户剩余流量只有45M，符合赠送流量资格，然后多线程T1模拟通信服务商赠送，假如某一用户已经被赠送过100M流量了，其他线程就会因为compareAndSet（）方法中的多项flow的值不等于变量f，而赠送失败，保证了每一个用户只会被充值一次。

多线程T2模拟用户使用流量，第44行，只要用户的剩余流量大于50M，就使用25M，否则低于50M就无法使用（虽然这样设计不合理- -、低于50M就无法使用25M流量，但这里为了模拟某一特定场景，就不太较真了，关键是要看多线程在赠送流量后，因为剩余流量仍低于50M而错误地继续赠送）。来看看运行结果：

可以看到，一开始线程检查到用户剩余流量低于50M，于是赠送了100M，接着用户同时不断地消耗流量，在用户剩余流量到45M后，又被重新赠送了一次，这是因为有多线程在不断扫描，且这个赠送流量线程采用的是无锁比较交换算法，只要用户的剩余流量不低于50M，就不断地重新获取用户剩余流量，直到低于50M后，再一次为这个用户赠送流量。

出现这种问题的原因在于，无锁比较交换线程中，对象V的值不等于期望值E，就会重新获取，线程只看重V的值和E是否相等，相等就做修改，如上面无锁栈中所说的，只看重结果，不看过程，假如其他线程把某一对象的值修改一次后，又修改会原来的值，那么其他线程就无法知道这个对象的值是否被修改过，因为它还是等于原来的 值。上面的模拟流量场景也是，虽然赠送线程给用户赠送了100M，可是消耗线程同时也在执行，使得赠送后用户的剩余流量还是低于50M，所以多线程赠送线程误以为该用户没有被赠送流量。

         解决的方法就是要“关注”这个过程信息，Java的atomic包中提供了AtomicStampedReference，与AtomicReference不同，它多了两个参数excpectedStamp和newStamp。这两个参数比较多人称它为版本号，也有人称它为时间戳，使用方法是这样：

package atomicstampedreference;

import java.util.concurrent.atomic.AtomicStampedReference;

public class SafeAtomicStampedReference {

	static AtomicStampedReference<Integer> flow = new AtomicStampedReference<Integer>(45, 0);
	
	public static void main(String[] args) {
		//模拟服务提供商赠送
		for(int i=0; i<1; i++) {
			final int time = flow.getStamp();
			Thread T1 = new Thread(new Runnable() {
				@Override
				public void run() {
					while(true) {
						for(;;) {
							Integer f = flow.getReference();
							 
							if(f<50) {
								//System.out.println("剩余流量小于50M,赠送100M....");
								if(flow.compareAndSet(f, f+100, time, time+10)) {
									System.out.println("流量充值成功!当前流量剩余:"+flow.getReference());
									break;
								}
							} else {
								break;
							}
						}
					}	
				}
			});
			T1.start();
		}
		
		for(int i=0; i<20; i++) {
			Thread T2 = new Thread(new Runnable() {
				@Override
				public void run() {
					while(true) {
						final int time = flow.getStamp();
						Integer f = flow.getReference();
						if(f>50) {
							System.out.println("剩余流量大于50M,使用流量....");
							if(flow.compareAndSet(f, f-25, time, time+10)) {
								System.out.println("流量使用25M,当前流量剩余:"+flow.getReference());
								break;
							}
						} else {
							System.out.println("剩余流量不足50M,无法使用.");
							break;
						}
						try {
							Thread.sleep(200);
						} catch(InterruptedException e) {
							e.printStackTrace();
						}
					}	
				}
			});
			T2.start();
		}
		
	}

}

第22行可以看到，每次做compareAndSet（）方法时，要先获得这个版本号/时间戳，做比较交换操作时，除了看对象的值和期望值E外，还要看这个时间戳，如果compareAndSet（）方法修改成功后，还要修改这个时间戳，这个时间戳可以用任何数来表示，你可以让它加10，也可以减10。使用AtomicStampedReference，只有当对象的值和时间戳都满足期望值时，才会修改，所以哪怕对象值被多次写入回到原值，但时间戳发生变化，就不会出现上面的问题。

完整代码已上传：

https://github.com/justinzengtm/Java-Multithreading/tree/master/Lock%20optimizations/AtomicStampedReference

大力海棠
关注
专栏目录
一个简单的无锁栈实现
07-31
一个简单的无锁栈， 使用原子操作，简单的资源回收。指针赋值使用compare_exchange_weak
CAS之AtomicStampedReference介绍及使用
qq_31086797的博客
06-30 2207
介绍 AtomicStampedReference是jdk提供的用于cas操作引用类型的一个类，相比于AtomicReference而已可以解决ABA问题，解决的原理就是用两个参数来对比是否做了更改，而第二个参数是个int值，只要保证第二个int值一直累加即不会存在aba问题 使用 场景：对一个Integer类型的对象cas自增 public class CasDemo { static AtomicStampedReference<Integer> atomicStampedRefe
原子引用与版本控制：深入AtomicStampedReference
最新发布
m0_62153576的博客
08-25 128
是一个强大的工具，它通过维护一个关联的整数值来帮助开发者处理复杂的并发问题。通过上述例子，我们可以看到它如何确保数据在多线程环境中的一致性和正确性。例如，考虑一个初始化数据的多步骤过程，在每个步骤中更新一个整数状态。在多线程环境中，数据的一致性和线程安全是编程中的重要考虑因素。类是一个强大的工具，它允许开发者原子性地更新引用对象及其关联的整数值（通常用作版本号或状态标记）。在这个例子中，我们模拟了一个数据服务，该服务在初始化过程中可能会被多个线程访问。，我们可以确保数据和状态的一致性。
AtomicStampedReference实现
demon7552003的小本本
05-25 491
AtomicStampedReference解决ABA问题 AtomicStampedReference与AtomicReference差异参考： 无锁的对象引用：AtomicReference 带有时间戳的对象引用：AtomicStampedReference AtomicStampedReference的实现 Pair类 Pair类存储原子对象以及时间戳 private...
实现无锁的栈与队列(5)：Hazard Pointer
weixin_34043301的博客
03-04 182
两年多以前随手写了点与 lock free 相关的笔记：1,2,3,4，质量都不是很高其实(读者见谅)，但两年来陆陆续续竟也有些阅读量了(可见剑走偏锋的技巧是多容易吸引眼球)。笔记当中在解决内存释放和 ABA 问题时提到了 Hazard Pointer 这个东西，有两三个读者来信问这是什么，让详细讲一下，我想了想，反正以前在看这东西的时候也记了些东西，干脆整理一下发出来。 前面写的那几篇笔记都来源...
AtomicStampedReference
u014162993的博客
02-12 157
AtomicReference底层： AtomicReference原子应用类，可以保证你在修改对象引用时的线程安全性，比较时可以按照偏移量进行 怎样使用AtomicReference： AtomicReference ar = new AtomicReference(); ar.set(“hello”); //CAS操作更新 ar.compareAndSet(“hello”, “hello1”); AtomicReference的成员变量： private static final long serial
无锁编程与无锁数据结构
无锁编程是一种并发编程的技术，用于解决多个线程或进程访问共享资源时可能出现的竞争和冲突问题。与传统的基于锁的并发编程方式相比，无锁编程可以提供更高的并发性和性能，同时减少资源争用和线程阻塞的情况。 ...
高并发系统设计精讲（十一）：无锁编程与CAS原子操作
无锁编程是一种并发编程的技术，它通过使用一些特殊的数据结构和算法，来实现在不需要依赖传统锁机制（如 synchronized 或 Lock）的情况下，保证数据的一致性和并发安全。在无锁编程中，线程不会被阻塞，而是通过...
共享模型之无锁
weixin_50458070的博客
10-16 130
黑马juc
Java synchronized与CAS无锁技术解析
为了解决这个问题，可以使用版本号或者AtomicStampedReference等数据结构来跟踪状态变化。 ## 3. Unsafe 类与 CAS 操作 在Java中，`sun.misc.Unsafe`类提供了底层的原子操作，包括CAS（compareAndSwapInt）等方法...
Java并发编程（3）—— Java多线程的锁机制和无锁并行
shangjg3的博客
11-05 221
Java 虚拟机在实现 monitorenter 字节码（申请锁）和 monitorexit 字节码（释放锁）时需要借助一个原子操作（CAS操作），这个操作是比较昂贵的，因此内部锁在每次被线程获取时，它都会将对应的线程记录为偏好线程（Biased Thread），之后此线程无论是再次申请该锁还是获取该锁，都无须借助原先昂贵的原子操作，从而减少了锁的申请与释放的开销。通常我们把被修饰的方法体和代码块称为临界区，需要注意的是必须保证多线程锁住的是同一个临界区，否则依然是线程不安全的。
无锁栈的实现
baochuanying9531的博客
10-05 135
template<typename T> class LockFreeStack { private: struct Node; struct CountedNode { int externalCount = 0; Node* ptr = nullptr; ...
并发编程--JAVA CAS的ABA问题及AtomicStampedReference的使用
penriver的博客
06-08 291
1. 基本概念 1.1. CAS CAS全称 Compare And Swap（比较与交换），是一种无锁算法。在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。java.util.concurrent包中的原子类就是通过CAS来实现了乐观锁。 CAS算法涉及到三个操作数： 需要读写的内存值 V。 进行比较的值 A。 要写入的新值 B。 当且仅当 V 的值等于 A 时，CAS通过原子方式用新值B来更新V的值（“比较+更新”整体是一个原子操作），否则不会执行任何操
无锁栈
CAir2的专栏
01-04 489
无锁多线程栈的实现主要是依赖了C的原子操作特性，例如：C++11里面的atomic的compare_exchange_xx，或者基本的InterlockedCompareExchange，都可以实现。下面我们将使用atomic实现。 #ifndef __SAFE_STACK_LL__ #define __SAFE_STACK_LL__ /* use cas mode support thre
无锁-栈
韩卫卫的博客
04-14 170
import java.util.concurrent.atomic.AtomicReference; /** * 线程安全的stack * * @param <T> * @author hanweiwei */ public class Stack<T> { private AtomicReference<Node<T>> tail = new AtomicReference<>(); public void p..
java 无锁栈_实现无锁的栈与队列(2)
weixin_34885009的博客
02-24 146
对于下面这个看起来很美好的无锁栈：1 //无锁的栈。23 typedef ELEM int;4 #define MAX (2048)56 staticELEM Stack[MAX];7 static int top = 0;89 boolPush(ELEM val)10 {11 intold_top;1213 do14 {15 old_...
实现无锁的栈与队列(3)
weixin_33950035的博客
07-07 125
怎样实现一个无锁队列，网络上有很多的介绍，其中流传最广，影响最大的恐怕就属于以下两篇论文： a) "Implementing lock free queue" by John.D.Valois b)"Simple, Fast, and Practical Non-Blocking and BlockingConcurrent Queue Algorithms"byM.M. Mic...
c++无锁栈
qq_35728402的博客
07-31 488
一个简单的无锁栈实现 /************************************************************************* &gt; File Name: lockfreestack.cpp &gt; Author: &gt; Mail: &gt; Created Time: Tue 31 Jul 2018 05:01:35 PM C...
实现无锁的栈
chenglinhust的专栏
07-08 1525
实现无锁的栈 1.关于CAS原子操作     在开始说无锁栈之前，我们需要知道一个很重要的技术就是CAS操作——Compare & Set，或是 Compare & Swap，现在几乎所有的CPU指令都支持CAS的原子操作，X86下对应的是 CMPXCHG 汇编指令。有了这个原子操作，我们就可以用其来实现各种无锁（lock free）的数据结构。 这个操作用C语言来描述就
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值