深入理解 CAS

最新推荐文章于 2022-01-02 23:05:30 发布
最新推荐文章于 2022-01-02 23:05:30 发布
阅读量2.8k 收藏 7
点赞数 3
分类专栏： # 深入理解源码系列 # JUC并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Woo_home/article/details/105024685
版权

文章目录


先来看下下面这段代码 

package juc;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author Woo_home
 * @create by 2020/3/21
 */
public class CASDemo {
    public static void main(String[] args) {
        // 原始值为 5
        AtomicInteger atomicInteger = new AtomicInteger(5);
        // 因为原始值和期望值相等，则更新值为 2019
        System.out.println(atomicInteger.compareAndSet(5,2019) + " current data : " + atomicInteger.get());
        // 由于上述已经将值改为 2019，所以与期望值比较不相等，不能更新值
        System.out.println(atomicInteger.compareAndSet(5,1024) + " current data : " + atomicInteger.get());
        // 获取最后修改成功的值
        System.out.println(atomicInteger.getAndIncrement());
    }
}

输出结果
在这里插入图片描述
可以发现 atomicInteger.getAndIncrement() 是一个原子的过程，因为获取到的是最新的值，那么这个方法是如何做到的呢？
在这里插入图片描述
该方法底层调用的是 Unsafe 类的 getAndAddInt 方法

  • this：代表的是当前对象
  • valueOffset：内存偏移量
  • 1：以原子方式将当前值增加一（固定的）

getAndAddInt

以下为 Unsafe 类的 getAndAddInt 方法

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
    	// 获取当前对象和内存地址偏移量
        var5 = this.getIntVolatile(var1, var2);
        // 如果当前对象(var1)的值(var2)跟(var5)一样，那么(var5 + 1)
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}
  • var1：AtomicInteger 对象本身
  • var2：该对象值的引用地址
  • var4：需要变动的数量
  • var5：是通过 var 1 、var 2 找出的主内存中的真实的值

用该对象当前的值与 var 5 进行比较
如果相同，则更新 var5+var4 并且返回 true
如果不同，则继续取值然后再比较，直到更新完成

在这里插入图片描述
假设线程 A 和线程 B 两个线程同时执行 getAndAddInt 操作（分别跑在不同的 CPU 上）：

（1）AtomicInteger 里面的 value 原始值是 3，即主内存中 AtomicInteger 的 value 为 3，根据 JMM 模型，线程 A 和线程 B 各自持有一份值为 3 的 value 的副本分别到各自的工作内存

（2）线程 A 通过 getIntVolatile(var1,var2) 拿到 value 值 3，这时线程 A 被挂起

（3）线程 B 也通过 getIntVolatile(var1,var2) 方法获取到 value 值 3，此时刚好线程 B 没有被挂起 并执行 compareAndSwapInt 方法比较内存值也为 3，成功修改内存值为 4，线程 B 打完收工，一切 OK

（4）这时线程 A 恢复，执行 compareAndSwapInt 方法比较，发现自己手里的值数字 3 和主内存中的值数字 4 不一致，说明该值已经被其它线程抢先一步修改过了，那 A 线程本次修改失败，只能重新读取重新来一遍了

（5）线程 A 重新获取 value 值，因为变量 value 被 volatile 修饰，所以其它线程对它的修改，线程 A 总是能够看到，线程 A 继续执行 compareAndSwapInt 进行比较替换，直到成功

Unsafe

在 AtomicInteger 中有这么一段代码
在这里插入图片描述

// 获取 Unsafe 这个类
private static final Unsafe unsafe = Unsafe.getUnsafe();

// 获取对象地址在这个内存中的偏移量
valueOffset = unsafe.objectFieldOffset

// value 被 volatile 修饰，保证原子性
private volatile int value;

Unsafe是 CAS 的核心类，由于 Java 方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe 相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe 类存在于 sun.misc 包中，其内部方法操作可以像 C 的指针一样直接操作内存，因为 Java 中 CAS 操作的执行依赖于 Unsafe 类的方法

注意 Unsafe 类中的所有方法都是 native 修饰的，也就是说 Unsafe 类中的方法都是直接调用操作系统底层资源执行相应任务

CAS

CAS 的全称为 Compare-And-Swap，它是一条 CPU 并发原语

优点

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的

CAS 并发原语体现在 Java 语言中就是 sun.misc.Unsafe 类中的各个方法，调用 Unsafe 类中的 CAS 方法，JVM 会帮我们实现出 CAS 汇编指令。这是一种完全依赖于 硬件 的功能，通过它实现了原子操作。再次强调，由于 CAS 是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说 CAS 是一条 CPU 的原子指令，不会造成所谓的数据不一致问题

缺点

自旋（循环时间长，开销大）

上面讲过 getAndAddInt 方法执行时，有个 do while 循环
在这里插入图片描述

如果 CAS 失败，会一直进行尝试。如果 CAS 长时间一直不成功，可能会给 CPU 带来很大的开销

只能保证一个共享变量的原子操作

当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁来保证原子性

ABA 问题

ABA 问题是怎么产生的？

CAS 算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差会导致数据的变化。

比如说一个线程 one 从内存位置 V 中取出 A，这时候另一个线程 two 也从内存中取出 A，并且线程 two 进行了一些操作将值变成了 B，然后线程 two 又将 V 位置的数据变成 A，这时候线程 one 进行 CAS 操作发现内存中仍然是 A，然后线程 one 操作成功

尽管线程 one 的 CAS 操作成功，但是不代表这个过程就是没有问题的

```java
package juc;

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

/**
 * @author Woo_home
 * @create by 2020/3/23
 * ABA 问题解决
 */
public class ABADemo {

    static AtomicReference<Integer> reference = new AtomicReference<>(100);

    public static void main(String[] args) {
        System.out.println("==================以下是 ABA 问题的产生======================");
        new Thread(() -> {
            reference.compareAndSet(100,101);
            reference.compareAndSet(101,100);
        },"t1").start();

        new Thread(() -> {
            try {
                // 暂停1秒钟t2线程，保证上面的t1线程完成了一次 ABA 操作
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(reference.compareAndSet(100,2019) + " " + reference.get());
        },"t2").start();
    }
}

从代码中可以发现，t1 线程将值 100，改为了 101，然后再从 101 改回了 100，然而 t2 以为 t1 并没有修改过值，所以 t2 将值修改为 2019
在这里插入图片描述

解决 ABA 问题

原子引用
package juc;

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

/**
 * @author Woo_home
 * @create by 2020/3/23
 * ABA 问题解决
 */
public class ABADemo {

    static AtomicReference<Integer> reference = new AtomicReference<>(100);
    static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100,1);
    public static void main(String[] args) {
        System.out.println("==================以下是 ABA 问题的产生======================");
        new Thread(() -> {
            reference.compareAndSet(100,101);
            reference.compareAndSet(101,100);
        },"t1").start();

        new Thread(() -> {
            try {
                // 暂停1秒钟t2线程，保证上面的t1线程完成了一次 ABA 操作
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(reference.compareAndSet(100,2019) + " " + reference.get());
        },"t2").start();

        System.out.println("==================以下是 ABA 问题的解决======================");

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 第1次版本号： " + stamp);
            try {
                // 暂停1秒钟t3线程
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stampedReference.compareAndSet(100,101,stampedReference.getStamp(),stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + " 第2次版本号： " + stampedReference.getStamp());
            stampedReference.compareAndSet(101,100,stampedReference.getStamp(),stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + " 第3次版本号： " + stampedReference.getStamp());
        },"t3").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 第1次版本号： " + stamp);
            try {
                // 暂停3秒钟t4线程
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = stampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + " 修改成功否： " + result + " 当前最新实际版本号： " + stampedReference.getStamp());
            System.out.println(stampedReference.getStamp() + " 当前实际最新值： " + stampedReference.getReference());
        },"t4").start();
    }
}

输出：
在这里插入图片描述
输出结果中黄色部分是 t1，t2 线程的，其它的是 t3，t4 线程的

Woo_home
关注
专栏目录
深入理解CAS (自旋锁)
流楚丶格念的博客
07-23 5185
CAS,compareandswap的缩写，中文翻译为比较并交换。CAS操作中包含三个操作数——内存位置(V)、预期原值(E)和新值(N)。这三个字母缩写的含义Variable变量；Expect预期；New新如果内存位置的值与预期原值相匹配，那么处理器会⾃动将该位置值更新为新值。否则，处理器不做任何操作。⽆论哪种情况，它都会在CAS指令之前返回该位置的值(在CAS的⼀些特殊情况下将仅返回CAS是否成功，而不提取当前值)。CAS用同步的方式。...
并发编程之深入理解CAS
最新发布
Huangjiazhen711的博客
11-03 378
CAS 和加锁相比，CAS 更加轻量，但也带来了两个问题一个是ABA问题、一个是自旋时间问题。
深入理解CAS
MindMrWang的blog
04-12 906
本文转自：https://blog.csdn.net/mine_song/article/details/70140596 但是好像这个链接也是转载的，我点进去他的链接，发现根本不是那篇文章！ 再将我看的那篇文章给的链接给出： 原文连接：http://blog.csdn.net/hechurui/article/details/49508473 如有侵权，请告知，立删！ 还有一篇写的Vo...
java 高性能并发二之 CAS
qq_353973854的博客
10-29 280
CAS：比较并交换（Compare-and-Swap） 1. CAS操作。 CAS虽然是看上去是两次操作，但其实际上是通过硬件来保证其只使用一条处理器指令就完成操作，所以CAS是一个原子操作。 CAS是一种乐观的并发策略，采用失败重试的方式。 CAS有3个操作数，(旧的)内存值V，预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。（可以将内存值...
并发编程 — AtomicStampedReference 详解
small_love的专栏
12-12 8400
AtomicInteger、AtomicBoolean、AtomicLong、AtomicReference 这些原子类型，它们无一例外都采用了基于 volatile 关键字 +CAS 算法无锁的操作方式来确保共享数据在多线程操作下的线程安全性。 volatile关键字保证了线程间的可见性，当某线程操作了被volatile关键字修饰的变量，其他线程可以立即看到该共享变量的变化。 CAS算法，即对比交换算法，是由UNSAFE提供的，实质上是通过操作CPU指令来得到保证的。CAS算法提供了一种快速失败的方式
AtomicStampedReference和AtomicMarkableReference详解
Dream_it_possible！的博客
01-02 1458
AtomicStampedReference和AtomicMarkableReference是解决CAS存在ABA问题的两种方案，他们俩的实现原理大致相同，弄明白AtomicStampedReference的实现原理，AtomicMarkableReference就迎刃而解了。 AtomicStampedReference AtomicStampedReference是JUC的atomic包里提供的一个类，官方解释该类的作用是: An AtomicStampedReference m...
二：CAS的理解
清风竹雨
11-08 522
CAS 是什么 CAS 的全称 Compare-And-Swap，它是一条 CPU 并发操作。 它的功能是判断内存某一个位置的值是否为预期，如果是则更改这个值，这个过程就是原子的。 CAS 并发原体现在 JAVA 语言中就是 sun.misc.Unsafe 类中的各个方法。调用 UnSafe 类中的 CAS 方法，JVM 会帮我们实现出 CAS 汇编指令。这是一种完全依赖硬件的功能，通...
深入理解CAS机制
m0_47396773的博客
01-21 245
深入理解CAS深入理解CAS定义与原理缺点CAS出现ABA问题示例代码解决ABA问题 深入理解CAS 定义与原理 ​ CAS：比较并交换（CompareAndSet）,它将指定内存位置的值与给定值进行比较，如果两个值相等，就将内存位置的值改为给定值，如果不是就一直循环。CAS涉及3个元素：内存地址，期盼值和目标值。只有内存地址对应的值和期望的值相同时，才把内存地址对应的值修改为目标值。 CAS在JAVA中的底层实现(Atomic原子类实现) Unsafe类。Unsafe类是CAS的核心类，由JDK自动加
深入理解CAS与AQS
╱/.独﹄無㈡oоΟ的博客
03-03 636
CAS与AQS一、CAS1、什么是CAS2、CAS进行原子操作的三大问题3、循环CAS二、AQS1、核心思想2、具体实现3、AQS 对资源的两种共享方式4、AQS 的应用 一、CAS 1、什么是CAS 首先，CAS是一种算法，不是锁 CAS，其实是个简称，全称是 Compare And Swap，对比之后交换数据 CAS的实现原理 首先呢，我们通过它的全称就可以看出来，CAS先是对比数据，然后再执行具体的原子操作。 几个参数介绍： this：Unsafe 对象本身，需要通过这个类来获取 valu
AtomicStampedReference使用方法
TigerChen
06-12 9762
我们都知道在使用CAS也就是使用compareAndSet（current，next）方法进行无锁自加或者更换栈的表头之类的问题时会出现ABA问题，Java中使用AtomicStampedReference来解决CAS中的ABA问题，它不再像compareAndSet方法中只比较内存中的值也当前值是否相等，而且先比较引用是否相等，然后比较值是否相等，这样就避免了ABA问题。那么AtomicStam...
AtomicStampedReference源码分析
杨航的专栏
01-29 175
之前的文章已经介绍过CAS的操作原理，它虽然能够保证数据的原子性，但还是会有一个ABA的问题。     那么什么是ABA的问题呢？假设有一个共享变量“num”,有个线程A在第一次进行修改的时候把num的值修改成了33。修改成功之后，紧接着又立刻把“num”的修改回了22。另外一个线程B再去修改这个值的时候并不能感知到这个值被修改过。     换句话说，别人把你账户里面的钱拿出来去投资，在你发现之前又给你还了回去，那这个钱还是原来的那个钱吗？你老婆出轨之后又回到了你身边，还是你原来的那个老婆吗？     
AtomicReference（无锁的对象引用）与AtomicStampedReference与（带有时间戳的对象引用）
Eric的博客
06-27 2696
AtomicReference与AtomicStampedReference 1、AtomicReference（无锁的对象引用）遇到的问题： 不懂AtomicReference，看了很多关于AtomicReference的资料，几乎都一样（都是复制的），运行基本看不到想要的结果。 自己研究了一下，分享出来。 2、使用实例： 场景：蛋糕店回馈客户，对于会员卡余额小于2
解决CAS机制中ABA问题的AtomicStampedReference
Jaemon
01-04 404
解决CAS机制中ABA问题的AtomicStampedReference
AtomicReference和AtomicStampedRerence整理与解析
小文的博客
10-18 1312
1.AtomicReference可以对“对象”进行原子操作。 // 使用 null 初始值创建新的 AtomicReference。 AtomicReference() // 使用给定的初始值创建新的 AtomicReference。 AtomicReference(V initialValue) // 如果当前值 == 预期值（引用相等，不是equals相等），则以原子方式将该值设置
入坑JAVA多线程并发(九）CAS和ABA
鱼机的编程之路
07-17 1307
　　如果了解数据库的悲观锁和乐观锁的话，对于理解CAS就很简单了，因为CAS就是乐观锁的具体实现。 　　悲观锁：在操作数据库时本能的觉得一定会有竞争，所以把数据锁住，不让其他事物对对应的数据进行操作，在本次操作之后把锁释放，其它事物才可以进行操作。这个在java里面就类似于synchronized。 　　乐观锁：在操作数据库时都觉得不会有其它事物和自己进行竞争，事物开始的时候就把对应的数据取出...
CAS了解及CAS容易发生的问题
summerZBH123的博客
06-10 5832
    CAS(Compare and Swap)比较和交换，是java在处理并发问题时，使用最多的一种方式，简单说就是，指定一个对象V，给出他的期望值，及需要修改的值，如果期望值等同于内存中的值，那么就把这个对象修改成我们想要改变的值，否则修改失败。 CAS使用最佳实践     先看下我们下面的场景： public class Case { public volatile in...
AtomicReference源码解析和使用
刘运召的博客
11-08 6397
AtomicReference是作用是对"对象"进行原子操作。 提供了一种读和写都是原子性的对象引用变量。原子意味着多个线程试图改变同一个AtomicReference(例如比较和交换操作)将不会使得AtomicReference处于不一致的状态
JUC并发编程（二十）-原子引用AtomicReference与AtomicStampedReferenc
二总的猫
02-26 656
20、原子引用：AtomicReference 原子类 AtomicInteger 的ABA问题谈谈？原子更新引用知道吗？ CAS 会导致 ABA的问题！ CAS算法的前提是：取出内存中某个时刻的数据，比较并交换！ 在这个时间差内有可能数据被修改！ 如下示例： package com.interview.concurrent.cas; import java.util.concurrent....
深入理解CAS底层原理与ABA问题及其应用
CAS(Compare And Swap, 比较并交换)算法是一种无锁并发控制机制，它在Java中通常通过sun.misc.Unsafe类的native方法实现，用于保证单个内存位置的...理解和掌握CAS的底层原理有助于开发人员设计出更高效的并发程序。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值