CAS中ABA问题的解决

最新推荐文章于 2025-10-23 06:15:00 发布
原创 最新推荐文章于 2025-10-23 06:15:00 发布 · 1.9k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #开发语言

本文详细解释了CAS（Compare and Swap）原理及其在并发编程中的应用，重点讨论了ABA问题的成因和解决策略，介绍了原子引用的概念及Java中的AtomicStampedReference。通过实例说明了如何通过版本号防止ABA问题，确保数据一致性。
  1. 什么是CAS？

    Compare and Swap (比较交换)，使用CAS来保证线程的对变量的原子操作，避免被其他线程所干扰。

  2. CAS原理：其中包含三个参数

    1. 要修改的变量

    2. 变量的预期值

    3. 要更性的参数

      在更新数据时，CAS先判断变量中的值与预期值，如果一致则更新为新值,如果变量的值与预期值不 一致，表示当前操作被其他线程干扰，此时线程不会阻塞而是自旋等待(自旋锁),重复以上操作，CAS操作即 使没有锁，也可以发现其他线程对当前线程的干扰，并进行恰当的处理。

      CAS在Java层面虽然没有使用锁保证原子性，但是在底层汇编对“比较替换”进行加锁保证其原子性操作。

    4. CAS可能存在的问题

      1. CPU开销较大

        在并发较高的情况下，如果许多线程反复尝试更改一个变量，却一直更新不成功，循环往复，会给CPU带来很大压力。看可以通过设置默认自旋次数来减少CPU消耗。

      2. 不能保证代码原子性

        CAS机制所保证的只是一个变量的原子性操作，而不能保证整个代码块的原子性。比如需要保证3个变量共同进行原子性的更新，就不得不使用synchronized了。

      3. ABA问题

        这是CAS机制存在的最大的问题。

  3. ABA问题

    什么是ABA问题？

    -在使用CAS进行变量的原子性操作时，先要获取一个预期值，然后再判断预期值与实际的值是否相同，如果相同则继续修改变量。由于CAS操作没有使用重量级锁，如果获得一个预期值后，实际的值被其他线程篡改为其他值，然后又被改回到原有的值，对于原线程来说，实际值和预期值是一样的，但实际上值已经被修改过。这样的问题就是ABA问题

    例如:t1线程进行CAS操作，获取的预期值为"A",在t1线程进行"比较交换"前，t2线程进入并将变量的值 由"A"改为"B",然后又重新改回到"A"并退出，此时对于t1线程来说，实际值和预期值都是"A",就可以 做"比较并交换"操作，但实际上，实际值"A"已被修改过。

  4. 如何解决ABA问题

    上述例子看似没有问题，但是结合实际就会发现其问题所在，举例如下：

    ，假设有一个遵循CAS的取款机，小明去取款机取款，此使账户余额100元,小明要取款50,但是由于故障取款机执行了两次取款线程:

    • 线程1:取款50,余额50

    • 线程2:取款50,余额50(失败)

      理想状况下之只能有一个线程执行成功,另一个线程执行失败,进入等待,但是此时小明的母亲给小明转账50元,此时:

    • 线程3:存款50,余额100元

      由于线程3执行成功,小明账户余额又到达了100元,此时线程2,通过cas比较交换,发现前后数据一致,所以可以进行数据改写.如下:

    • 线程2:取款50,余额50

      此时不难发现小明的余额少了50元.这就是ABA问题.那么我们如何解决呢?

    • 我们可以使用CAS中的"原子引用"来解决ABA问题.

      原子引用是基于乐观锁的思想,为CAS中的每个操作添加一个版本号,每次执行成功之后,都会对版本号进行+1操作,每次更新数据之前都会对比版本号,观察是否有其他线程进行干扰.如果版本号一制则继续,不一致进入自旋.

      Java中提供了AtomicStampedReference类来实现原子引用并可以设置版本号

CAS、ABA - AtomicInteger 源码解析，自旋锁实现，以及 ABA 问题详解
CYK_byte的博客
09-25 1348
CAS（Compare-and-Swap）顾名思义，叫做比较和交换，大概执行过程是什么样呢？假设现有两个寄存器A、B和一个内存M，通过对寄存器A中的值与内存M的值进行比较是否相同，来决定寄存器B中的值是否与内存中M的值进行交换，若不相同则不会发生什么，若相同则将寄存器B的值与内存M的值进行交换；总结：CAS是CPU的一条指令，原子性完成的，线程安全，效率也很高；
CAS ABA问题及解决方案示例
04-04 965
CAS ABA问题 ABA问题是CAS机制中出现的一个问题，他的描述是这样的。我们直接画一张图来演示， 什么意思呢？就是说一个线程把数据A变为了B，然后又重新变成了A。此时另外一个线程读取的时候，发现A没有变化，就误以为是原来的那个A。这就是有名的ABA问题。ABA问题会带来什么后果呢？我们举个例子。 一个小偷，把别人家的钱偷了之后又还了回来，还是原来的钱吗，你老婆出轨之后又回来，还是原来的老婆嘛？ABA问题也一样，如果不好好解决就会带来大量的问题。最常见的就是资金问题，也就是别人如果挪用了你的
【大厂面试题系列】：如何解决CAS的ABA问题
Code皮皮虾的博客
03-19 1049
CAS解决ABA问题 ABA问题产生 如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回A，那CAS操作就会误认为它从来没有被修改过。这个问题被称为CAS操作的 "ABA"问题。 public class ABADemo { static AtomicReference<Integer> atomicReference = new Atomi..
CAS算法详解 ABA问题以及解决办法
HO1_K的博客
09-15 2272
前言 近日，阅读并发相关知识时，频繁的看到有关CAS词汇的相关知识，就称此机会做个总结，把自己理解的CAS算法梳理一下，做个记录以便以后查阅。 一. 什么是CAS算法 1. CAS算法：全称 compare and swap，比较并交换。CAS是原子操作的一种，可用于在多线程编程中实现不被打断的数据交换操作，从而避免多线程同时改写某一数据时由于执行顺序不确定性以及中断的不可预知性产生的数据不一致问题。 该操作通过将内存中的值与指定数据进行比较，当数值一样时将内存中的数据替换为新的值。 2. C.
什么是ABA问题？如何解决？一篇文章教会你，再也不怕面试官深挖啦！
最新发布
m0_60715044的博客
10-23 844
乐观锁中的ABA 问题，本质是 “值的表象未变，但中间可能被修改过” 导致的误判。例如：线程 1 读取值为 A，线程 2 将 A 改为 B，再改回 A，线程 1 的 CAS 操作会认为 “值未变” 而成功执行，但实际中间已发生过修改。解决 ABA 问题的核心是通过额外维度记录 “修改历史”，让 “值的变化轨迹” 可追溯，而非仅依赖当前值判断。解决 ABA 问题的关键是打破 “仅通过当前值判断是否修改” 的逻辑。
【JavaEE】多线程CAS中的aba问题是什么？
xyk：的博客
04-15 1380
所属专栏:什么是CAS问题？CAS: 全称Compare and swap，字面意思:”比较并交换“，CAS中的aba问题是什么？请看下面讲解~~CAS: 全称Compare and swap，字面意思:”比较并交换“，寄存器A的值和内存M的值进行对比，如果值相同，就把寄存器B的值和M的值进行交换~~一个 CAS 涉及到以下操作：
CAS之ABA问题的解决方法
java_dazhuzhu的博客
08-09 317
AtomicReference java.util.concurrent.atomic包下的AtomicInteger类可以对整数进行包装，使得类似于i++的操作可以变成原子操作，那么对于一般的对象类型要怎么实现原子操作呢,从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性。 public class AtomicReferenceDemo { static AtomicReference<Student> stu = new Atomi
CAS的ABA问题及解决方法
yang_154116的博客
07-21 9032
一、什么是ABA问题？ 考虑如下操作： 并发1（上）：获取出数据的初始值是A，后续计划实施CAS乐观锁，期望数据仍是A的时候，修改才能成功 并发2：将数据修改成B 并发3：将数据修改回A 并发1（下）：CAS乐观锁，检测发现初始值还是A，进行数据修改   上述并发环境下，并发1在修改数据时，虽然还是A，但已经不是初始条件的A了，中间发生了A变B，B又变A...
CAS下ABA问题及优化方案
07-03
ABA问题的出现原因是CAS乐观锁机制中，只简单地进行了“值”的校验，而没有确保的是原来的数据。例如，在库存扣减业务中，用户1和用户2同时执行库存扣减操作，CAS乐观锁机制检查通过后，执行修改操作，但是在执行...
真实业务场景展现CAS原理的ABA问题及解决方案
热门推荐
cauchy6317的博客
09-25 2万+
文章目录阅读提示CAS原理、ABA问题介绍真实业务场景如何解决ABA问题CAS学习总结 阅读提示 本文将借助开保险柜的业务场景重点阐述误用AtomicBoolean引起的ABA问题，以及解决方案。基于此，请先深入理解CAS原理，以及其会产生的ABA问题。关于CAS原理和ABA问题的优秀博客已经存在很多，所以本文只简单介绍CAS原理，希望读者有此基础。 CAS原理、ABA问题介绍 CAS（Compare and Swap）是一种乐观锁机制。CAS有3个操作数，预期值A，内存值V，要修改的新值B。当且仅当预期值
多线程(CAS, ABA问题, Runnable & Callable & 僵尸线程 & 孤儿进程)
shianla的博客
03-21 688
假设存在两个线程 t1 和 t2, 存在共享变量为 num, 初始值为 A.接下来,线程 t1想使用 CAS 把num值改成Z, 那么就需要先读取num的值, 记录到oldNum变量中使用 CAS 判定num的值是否等于oldNum, 如果相等, 那么将Z写入num那么如果在这两个步骤之间,t2线程对num进行了操作, 把num的值从A改成了B, 又从B改成了A对于线程 t1来说,A->B->A的变换不可见, 但是仍会进行第二步操作, 即, 这就是ABA问题: CAS 的误判。
【面试必问系列】之如何解决CAS的ABA问题？
一个喜欢诗和远方的程序媛
01-15 1164
CAS：Compare and Swap，比较并交换。java.util.concurrent包中借助CAS实现了区别于synchronouse同步锁的一种乐观锁。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
CAS算法中的ABA问题的解决
荣山的博客
12-12 1896
CAS算法中的ABA问题的解决
CAS机制是什么，如何解决ABA问题
riemann_的博客
08-03 5249
将之前我们先来了解独占锁和乐观锁。 独占锁：是一种悲观锁，synchronized就是一种独占锁，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。 乐观锁：每次不加锁，假设没有冲突去完成某项操作，如果因为冲突失败就重试，直到成功为止。 一、CAS 操作 乐观锁用到的机制就是CAS，Compare and Swap。 CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值...
使用CAS解决ABA问题
倔强100%的博客
11-03 548
CAS是什么 CAS是java利用unsafe类通过对计算机底层的调用来进行数据的操作。底层实现为自旋锁。 测试 public class CASDemo { public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(2020); // public final boolean compareAndSet(int expect, int update)
解决CAS中ABA问题
test1_12的博客
12-10 907
ABA：当线程1要将A->C,但是其他线程在线程1执行过程中将A->B,然后又将B->A，这时候线程1cas时会成功执行,但是无法判断A是已经被改过的. 解决: AtomicStampedReference通过这个原子类，使用版本号的方式解决ABA问题. static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0); public static voi...
CAS如何解决ABA问题
w1103257009的博客
08-18 272
线程1进行CAS操作，获取预估值为"A"，在线程1进行“比较交换”前，线程2进入并将变量的值由"A"改为“B”，然后又重新改回到"A"并退出，此时对于线程来说，预估值与实际值都为"A"，可以进行"比较交换"操作，但是实际上，"A"被修改过。当一个线程要对一个变量进行CAS操作时，会先进行变量值的比对，即要修改的变量值是否与预期的变量值是否一致，一致代表该变量当前没有被其他线程使用，可以进行修改，否则线程会进入自旋锁状态，重复以上操作。首先涉及到三个参数：要修改的变量、预期的变量值、修改后的变量值。
CAS的ABA问题及其解决方案
qq_46130027的博客
05-27 2239
CAS锁的ABA问题是指在使用CAS锁时，由于CAS算法实现一个重要前提是需要取出内存中某时刻的数据，而在下一时刻比较并替换，那么在这个时间差内会导致数据的变化。当有多个线程对某一个原子类进行操作的时候，某个线程将原值A改成了B，又改回了A，此时另一个线程也对该值进行操作，发现它的值仍然是A，就会认为它没有被修改过，从而执行CAS操作。这是就是ABA问题。
如何解决 CAS 中的 ABA 问题？
08-02
### ABA问题的本质 ABA问题是CAS（Compare and Swap）操作中的一种典型问题，指的是一个值在被其他线程修改后，又被改回了原来的值。这种情况下，CAS操作会误认为值没有被改变，从而导致数据一致性问题。这种问题的核心在于内存中值的变化过程未被记录，无法反映其版本变化的历史[^3]。 ### ABA问题的解决方案 为了解决ABA问题，通常需要引入额外的机制来记录值的变化过程。以下是两种常见的解决方案： 1. **版本号机制** 通过为值添加一个版本号，每次值发生变化时，版本号也会递增。在进行CAS操作时，不仅比较值是否相等，还需要比较版本号是否一致。这种方法确保了即使值被改回，只要版本号不同，CAS操作也会失败，从而避免误判。例如，Java中的`AtomicStampedReference`类就实现了这种机制，通过记录值的版本来解决ABA问题[^2]。 ```java // 示例代码：使用 AtomicStampedReference 解决 ABA 问题 import java.util.concurrent.atomic.AtomicStampedReference; public class ABAExample { public static void main(String[] args) { // 初始值和版本号 AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100, 0); Thread t1 = new Thread(() -> { int expectedValue = 100; int newValue = 50; int stamp = stampedReference.getStamp(); // 获取当前版本号 if (stampedReference.compareAndSet(expectedValue, newValue, stamp, stamp + 1)) { System.out.println("T1 更新值成功: " + newValue + "，版本号: " + stampedReference.getStamp()); } }); Thread t2 = new Thread(() -> { int expectedValue = 100; int newValue = 200; int stamp = stampedReference.getStamp(); // 获取当前版本号 if (stampedReference.compareAndSet(expectedValue, newValue, stamp, stamp + 1)) { System.out.println("T2 更新值成功: " + newValue + "，版本号: " + stampedReference.getStamp()); } }); t1.start(); t2.start(); } } ``` 2. **标志位机制** 另一种解决方案是使用标志位，通过记录值是否被修改过的状态来解决ABA问题。Java中的`AtomicMarkableReference`类通过一个布尔值标志位来标记值是否被修改过。这种方法适用于只需要记录值是否发生变化的场景[^2]。 ```java // 示例代码：使用 AtomicMarkableReference 解决 ABA 问题 import java.util.concurrent.atomic.AtomicMarkableReference; public class ABAExample { public static void main(String[] args) { // 初始值和标志位 AtomicMarkableReference<Integer> markableReference = new AtomicMarkableReference<>(100, false); Thread t1 = new Thread(() -> { int expectedValue = 100; int newValue = 50; boolean[] mark = new boolean[1]; mark[0] = markableReference.isMarked(); // 获取当前标志位 if (markableReference.compareAndSet(expectedValue, newValue, mark[0], !mark[0])) { System.out.println("T1 更新值成功: " + newValue + "，标志位: " + markableReference.isMarked()); } }); Thread t2 = new Thread(() -> { int expectedValue = 100; int newValue = 200; boolean[] mark = new boolean[1]; mark[0] = markableReference.isMarked(); // 获取当前标志位 if (markableReference.compareAndSet(expectedValue, newValue, mark[0], !mark[0])) { System.out.println("T2 更新值成功: " + newValue + "，标志位: " + markableReference.isMarked()); } }); t1.start(); t2.start(); } } ``` ### 总结 通过引入版本号或标志位机制，可以有效解决CAS操作中的ABA问题。这些机制通过记录值的变化历史，确保了在并发环境下数据的一致性和正确性。尽管这些方法会带来额外的内存和计算开销，但在需要严格数据一致性的场景下，它们是不可或缺的解决方案[^3]。 ---
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值