详解两种解决 CAS 中 ABA 问题的方式 - AtomicStampedReference 和 AtomicMarkableReference 的使用及其原理

原创 已于 2023-06-03 20:57:18 修改 · 1.9k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #CAS #多线程 #并发编程 #线程安全

于 2022-11-10 17:36:41 首次发布
本文介绍了Java中的CAS（Compare and Swap）操作，这是一种乐观锁的实现方式，用于在多线程环境下无锁地更新数据。文章还讨论了CAS可能导致的ABA问题，即值在比较和交换过程中发生了变更又变回原值。为解决ABA问题，文章提出了使用AtomicStampedReference和AtomicMarkableReference的方法，这两个类能记录数据的版本或标记，确保在更新时能检测到中间的变化。

目录

什么是 CAS ？

Demo

CAS 引发的 ABA 问题

什么是 ABA ？

Demo

两种解决方案

使用 AtomicStampedReference

AtomicStampedReference 示例

AtomicStampedReference 原理

AtomicMarkableReference 原理

 

什么是 CAS ？

        CAS（compare and swap / set），即所谓的比较并交换，它是一种乐观锁的落地实现。在 Java 中锁分为乐观锁和悲观锁。悲观锁是将共享资源独自占有，其它线程不能访问此共享资源，只有等占有资源的线程释放锁之后，下一个线程才可以访问。乐观锁的主要思想是通过某种方式不加锁来处理资源，例如给记录加版本号（version）来获取数据，性能较悲观锁有很大的提升。

        CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值（B）。如果内存地址里面的值和预期原值（A）相同，那么就将内存里面的值更新成新值（B）。CAS是通过循环来获取数据的，如果在第一轮循环中，有一个线程获取地址里面的值被另一个线程修改了，那么此线程需要进行自旋重试，直到 CAS 成功。

Demo


                

        

    



  


        

            

                      
                        最低0.47元/天 解锁文章
                          
                      
            

        


    



                



	

		

			

				
					
揭秘CAS：深入理解与应用解析

				
			

			

				

					曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
				

				

					01-17
					
					84万+
					
				

			

		

		

			
				
在并发编程中，Compare-And-Swap（CAS）机制作为一种无锁算法，凭借其高效性和避免线程阻塞的优势，受到广泛关注。CAS不仅在底层实现上有着重要地位，还在实际开发中发挥着关键作用。本文将从CAS的工作原理、在Java中的实现及其增强机制来回顾和加深理解一下CAS。

			
		

	



                

            
              



	

		

			

				
					
Java 中的 CAS和ABA和自旋开销和 Atomic 原子操作包讲解和案例示范

				
			

			

				

					J老熊
				

				

					10-13
					
					1001
					
				

			

		

		

			
				
在高并发的电商交易系统中，如何保证数据的一致性与并发的安全性是开发者必须面对的关键问题。为了高效地处理并发问题，Java 提供了多种机制，其中 CAS（Compare-And-Swap，比较并交换）和 `java.util.concurrent.atomic` 包中的原子操作工具类是重要的工具之一。通过这些机制，开发者可以在保证线程安全的前提下减少锁的使用，提升系统的性能。

			
		

	



              


  
              

                


	

		

			

				
					
【AtomicReference、AtomicStampedReference】常规用法

				
			

			

				

					『程序员·小李』的博客
				

				

					08-11
					
					1165
					
				

			

		

		

			
				
AtomicReference可以针对引用类型进行原子操作。

			
		

	





	

		

			

				
					
并发编程学习笔记 之 原子操作类AtomicReference、AtomicStampedReference详解

				
			

			

				

					向心行者
				

				

					07-12
					
					867
					
				

			

		

		

			
				
  在《并发编程学习笔记 之 原子操作类AtomicInteger详解》中，我们学习了原子操作类AtomicInteger的用法，类似的还有AtomicLong、AtomicBoolean等类型，这些都是针对基本类型定义的原子性操作，那么针对对象是否有原子性操作呢？这一节，我们就开始学习原子操作类AtomicReference，看看如何实现针对对象的原子性操作。  这里我们改写了《Java高并发编程详解：深入理解并发核心库》一书中的例子，设计一个个人银行账号资金变化的场景：  首先，我们设计一个个人银行账号

			
		

	



		

			
		



	

		

			

				
					
Java并发中的ABA问题：使用AtomicStampedReference解决CAS的致命缺陷

					
最新发布

				
			

			

				

					weixin_41455464的博客
				

				

					10-28
					
					503
					
				

			

		

		

			
				
CAS操作虽然高效，但存在ABA问题。

			
		

	





	

		

			

				
					
J.U.C 原子类系列之AtomicReference、AtomicStampedReference、AtomicMarkableReference

				
			

			

				

					qq_37212210的博客
				

				

					06-19
					
					402
					
				

			

		

		

			
				
简介
上一篇文章详细讲解了AtomicInteger原子类，还有和AtomicInteger原子类实现原理基本一样的AtomicLong和AtomicBoolean原子类。这些都是基本数据类型的原子类，在并发情景下可以保证基本数据类型变量的原子性。但是对于引用类型，这些基本类型的原子类就无能为力了，所以就出现对象引用类型的原子类。
对象引用类型的原子类包括：AtomicReference、Atom...

			
		

	





	

		

			

				
					
AtomicStampedReference使用

				
			

			

				

					//Case
				

				

					04-28
					
					1790
					
				

			

		

		

			
				
//构造方法, 传入引用和戳
public AtomicStampedReference(V initialRef, int initialStamp)
//返回引用
public V getReference()
//返回版本戳
public int getStamp()
//如果当前引用 等于 预期值并且 当前版本戳等于预期版本戳, 将更新新的引用和新的版本戳到内存
public boolea...

			
		

	





	

		

			

				
					
AtomicStampedReference使用方法

					
热门推荐

				
			

			

				

					TigerChen
				

				

					06-12
					
					1万+
					
				

			

		

		

			
				
我们都知道在使用CAS也就是使用compareAndSet（current，next）方法进行无锁自加或者更换栈的表头之类的问题时会出现ABA问题，Java中使用AtomicStampedReference来解决CAS中的ABA问题，它不再像compareAndSet方法中只比较内存中的值也当前值是否相等，而且先比较引用是否相等，然后比较值是否相等，这样就避免了ABA问题。那么AtomicStam...

			
		

	





	

		

			

				
					
AtomicStampedReference和AtomicMarkableReference详解

				
			

			

				

					 Dream_it_possible！的博客
				

				

					01-02
					
					1836
					
				

			

		

		

			
				
AtomicStampedReference和AtomicMarkableReference是解决CAS存在ABA问题的两种方案，他们俩的实现原理大致相同，弄明白AtomicStampedReference的实现原理，AtomicMarkableReference就迎刃而解了。

AtomicStampedReference

AtomicStampedReference是JUC的atomic包里提供的一个类，官方解释该类的作用是:


An AtomicStampedReference m...

			
		

	





	

		

			

          精选资源
				
					
Java 多线程与并发(8-26)-JUC原子类- CAS, Unsafe和原子类详解.pdf

				
			

			

				

					07-23
				

			

		

		

			
				
为了解决ABA问题，Java提供了AtomicStampedReference和AtomicMarkableReference类。这两个类在操作值的时候，会一同更新一个"版本号"或"标记"，从而避免ABA问题。此外，自旋CAS长时间不成功可能会导致CPU资源的浪费...

			
		

	





	

		

			

				
					
CAS之AtomicStampedReference介绍及使用

				
			

			

				

					qq_31086797的博客
				

				

					06-30
					
					2603
					
				

			

		

		

			
				
介绍
AtomicStampedReference是jdk提供的用于cas操作引用类型的一个类，相比于AtomicReference而已可以解决ABA问题，解决的原理就是用两个参数来对比是否做了更改，而第二个参数是个int值，只要保证第二个int值一直累加即不会存在aba问题
使用
场景：对一个Integer类型的对象cas自增
public class CasDemo {

    static AtomicStampedReference<Integer> atomicStampedRefe

			
		

	





	

		

			

				
					
AtomicStampedReference

				
			

			

				

					weixin_41029286的博客
				

				

					09-10
					
					508
					
				

			

		

		

			
				
AtomicInteger，AtomicBoolean，AtomicReference都是根据value的是否变化来做cas修改的，但是这样无法解决ABA的问题
AtomicStampedReference类不仅比较了对象还比较了版本号
AtomicStampedReference的使用
        Object obj = new Object();
        int initialStamp = 0;
        AtomicStampedReference atomicStampedRe

			
		

	





	

		

			

				
					
AtomicStampedReference 使用方法

				
			

			

				

					Coder_xh的博客
				

				

					03-11
					
					1337
					
				

			

		

		

			
				
我们都知道在使用 CAS 也就是使用 compareAndSet（current，next）方法进行无锁自加或者更换栈的表头之类的
问题时会出现ABA问题，Java中使用 AtomicStampedReference 来解决 CAS 中的ABA问题，它不再像 compareAndSet 方法
中只比较内存中的值也当前值是否相等，而且先比较引用是否相等，然后...

			
		

	





	

		

			

				
					
Atomicstampedreference的使用（如何解决aba问题）

				
			

			

				

					u011982711的博客
				

				

					02-03
					
					552
					
				

			

		

		

			
				
Atomicstampedreference的使用（如何解决aba问题）


public class AtomicstampedreferenceTest {
    public static void main(String[] args){
        AtomicStampedReference<Integer> reference=new AtomicStampedReference<>(1,1);
        new Thread(new Runnable().

			
		

	





	

		

			

				
					
CAS的ABA问题及解决方法

				
			

			

				

					yang_154116的博客
				

				

					07-21
					
					9031
					
				

			

		

		

			
				
一、什么是ABA问题？

考虑如下操作：


	并发1（上）：获取出数据的初始值是A，后续计划实施CAS乐观锁，期望数据仍是A的时候，修改才能成功
	
	
	并发2：将数据修改成B
	
	
	并发3：将数据修改回A
	
	
	并发1（下）：CAS乐观锁，检测发现初始值还是A，进行数据修改
	
 

上述并发环境下，并发1在修改数据时，虽然还是A，但已经不是初始条件的A了，中间发生了A变B，B又变A...

			
		

	





	

		

			

				
					
并发编程——使用AtomicStampedReference解决ABA问题

				
			

			

				

					换了马甲的小强的博客
				

				

					03-22
					
					456
					
				

			

		

		

			
				
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABA {

	private static AtomicInteger at...

			
		

	





	

		

			

				
					
AtomicStampedReference是怎样解决CAS的ABA问题

				
			

			

				

					捉虫大师
				

				

					10-27
					
					312
					
				

			

		

		

			
				
本文已收录 https://github.com/lkxiaolou/lkxiaolou 欢迎star。

什么是ABA问题
但凡对Java有一点深入就会知道 CAS，即 compareAndSwap。在Java中使用 Unsafe 类提供的native方法可以直接操作内存，其中就有对compareAndSwap的实现。
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object .

			
		

	





	

		

			

				
					
java解决aba_详解解决CAS机制中ABA问题的AtomicStampedReference

				
			

			

				

					05-19
				

			

		

		

			
				
在多线程编程中，CAS（Compare and Swap）机制被广泛使用。它可以实现无锁并发，提高程序的性能。但是，CAS 机制存在 ABA 问题，即当一个值从 A 变为 B，再从 B 变回 A，这时另一个线程也会执行相同的操作，而我们无法区分这两次操作是否真正修改了值。为了解决这个问题，Java 提供了一个原子类 AtomicStampedReference。

AtomicStampedReference 可以保证在进行 CAS 操作时，不仅比较对象值是否相等，还会比较对象的时间戳是否相等。时间戳是一个整数值，每次对象值的改变都会导致时间戳的变化。因此，即使对象值从 A 变为 B，再从 B 变回 A，时间戳也会发生变化，从而避免了 ABA 问题的出现。

下面是一个使用 AtomicStampedReference 解决 ABA 问题的示例代码：

```java
import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicStampedReferenceDemo {
    static AtomicStampedReference<Integer> reference = new AtomicStampedReference<>(1, 0);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = reference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 第 1 次版本号：" + stamp);
            reference.compareAndSet(1, 2, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + " 第 2 次版本号：" + reference.getStamp());
            reference.compareAndSet(2, 1, reference.getStamp(), reference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + " 第 3 次版本号：" + reference.getStamp());
        }, "线程 1").start();

        new Thread(() -> {
            int stamp = reference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 第 1 次版本号：" + stamp);
            // 等待线程 1 完成 CAS 操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean isSuccess = reference.compareAndSet(1, 3, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + " 是否修改成功：" + isSuccess);
            System.out.println(Thread.currentThread().getName() + " 当前版本号：" + reference.getStamp());
            System.out.println(Thread.currentThread().getName() + " 当前值：" + reference.getReference());
        }, "线程 2").start();
    }
}
```

输出结果：

```
线程 1 第 1 次版本号：0
线程 1 第 2 次版本号：1
线程 1 第 3 次版本号：2
线程 2 第 1 次版本号：0
线程 2 是否修改成功：false
线程 2 当前版本号：2
线程 2 当前值：1
```

通过输出结果可以看出，线程 2 尝试将值从 1 改为 3，但是由于版本号已经被线程 1 修改过了，因此 CAS 操作失败，避免了 ABA 问题的出现。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值