并发编程之深入理解CAS

最新推荐文章于 2023-05-08 23:26:24 发布
最新推荐文章于 2023-05-08 23:26:24 发布
阅读量137 收藏
点赞数
分类专栏： 基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37607945/article/details/121616714
版权

并发编程系列

什么是 CAS

CAS（Compare And Swap，比较并交换），通常指的是这样一种原子操作：针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。
CAS 的逻辑用伪代码描述如下：

if (value == expectedValue) {
    value = newValue;

以上伪代码描述了一个由比较和赋值两阶段组成的复合操作，CAS 可以看作是它们合并后的整体——一个不可分割的原子操作，并且其原子性是直接在硬件层面得到保障的。
CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，Java原子类中的递增操作就通过CAS自旋实现的。
CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。

CAS应用

在 Java 中，CAS 操作是由 Unsafe 类提供支持的，该类定义了三种针对不同类型变量的 CAS 操作，如图
在这里插入图片描述
它们都是 native 方法，由 Java 虚拟机提供具体实现，这意味着不同的 Java 虚拟机对它们的实现可能会略有不同。
以 compareAndSwapInt 为例，Unsafe 的 compareAndSwapInt 方法接收 4 个参数，分别是：对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行 CAS 操作。

public class CASTest {

    public static void main(String[] args) {
        Entity entity = new Entity();

        Unsafe unsafe = UnsafeFactory.getUnsafe();

        long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");

        boolean successful;

        // 4个参数分别是：对象实例、字段的内存偏移量、字段期望值、字段新值
        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful + "\t" + entity.x);
    }
}

public class UnsafeFactory {

    /**
     * 获取 Unsafe 对象
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取字段的内存偏移量
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }

测试
针对 entity.x 的 3 次 CAS 操作，分别试图将它从 0 改成 3、从 3 改成 5、从 3 改成 8。

CAS源码分析

Hotspot 虚拟机对compareAndSwapInt 方法的实现如下：

#unsafe.cpp
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  // 根据偏移量，计算value的地址
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  // Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值   e:要比较的值
  //cas成功，返回期望值e，等于e,此方法返回true 
  //cas失败，返回内存中的value值，不等于e，此方法返回false
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;

核心逻辑在Atomic::cmpxchg方法中，这个根据不同操作系统和不同CPU会有不同的实现。这里我们以linux_64x的为例，查看Atomic::cmpxchg的实现

#atomic_linux_x86.inline.hpp
inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  //判断当前执行环境是否为多处理器环境
  int mp = os::is_MP();
  //LOCK_IF_MP(%4) 在多处理器环境下，为 cmpxchgl 指令添加 lock 前缀，以达到内存屏障的效果
  //cmpxchgl 指令是包含在 x86 架构及 IA-64 架构中的一个原子条件指令，
  //它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等，
  //如果相等，则双向交换 dest 与 exchange_value，否则就单方面地将 dest 指向的内存值交给exchange_value。
  //这条指令完成了整个 CAS 操作，因此它也被称为 CAS 指令。
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;

cmpxchgl的详细执行过程：
首先，输入是"r" (exchange_value), “a” (compare_value), “r” (dest), “r” (mp)，表示compare_value存入eax寄存器，而exchange_value、dest、mp的值存入任意的通用寄存器。嵌入式汇编规定把输出和输入寄存器按统一顺序编号，顺序是从输出寄存器序列从左到右从上到下以“%0”开始，分别记为%0、%1···%9。也就是说，输出的eax是%0，输入的exchange_value、compare_value、dest、mp分别是%1、%2、%3、%4。
因此，cmpxchg %1,(%3)实际上表示cmpxchg exchange_value,(dest)
需要注意的是cmpxchg有个隐含操作数eax，其实际过程是先比较eax的值(也就是compare_value)和dest地址所存的值是否相等，
输出是"=a" (exchange_value)，表示把eax中存的值写入exchange_value变量中。
Atomic::cmpxchg这个函数最终返回值是exchange_value，也就是说，如果cmpxchgl执行时compare_value和dest指针指向内存值相等则会使得dest指针指向内存值变成exchange_value，最终eax存的compare_value赋值给了exchange_value变量，即函数最终返回的值是原先的compare_value。此时Unsafe_CompareAndSwapInt的返回值(jint)(Atomic::cmpxchg(x, addr, e)) == e就是true，表明CAS成功。如果cmpxchgl执行时compare_value和(dest)不等则会把当前dest指针指向内存的值写入eax，最终输出时赋值给exchange_value变量作为返回值，导致(jint)(Atomic::cmpxchg(x, addr, e)) == e得到false，表明CAS失败。

现代处理器指令集架构基本上都会提供 CAS 指令，例如 x86 和 IA-64 架构中的 cmpxchgl 指令和 comxchgq 指令，sparc 架构中的 cas 指令和 casx 指令。
不管是 Hotspot 中的 Atomic::cmpxchg 方法，还是 Java 中的 compareAndSwapInt 方法，它们本质上都是对相应平台的 CAS 指令的一层简单封装。CAS 指令作为一种硬件原语，有着天然的原子性，这也正是 CAS 的价值所在。

CAS缺陷

CAS 虽然高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方面：

  • 自旋 CAS 长时间地不成功，则会给 CPU 带来非常大的开销
  • 只能保证一个共享变量原子操作
  • ABA 问题

ABA问题及其解决方案

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

什么是ABA问题

当有多个线程对一个原子类进行操作的时候，某个线程在短时间内将原子类的值A修改为B，又马上将其修改为A，此时其他线程不感知，还是会修改成功。
在这里插入图片描述

@Slf4j
public class ABATest {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread1 read value: " + value);

            // 阻塞1s
            LockSupport.parkNanos(1000000000L);

            // Thread1通过CAS修改value值为3
            if (atomicInteger.compareAndSet(value, 3)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread2 read value: " + value);
            // Thread2通过CAS修改value值为2
            if (atomicInteger.compareAndSet(value, 2)) {
                log.debug("Thread2 update from " + value + " to 2");

                // do something
                value = atomicInteger.get();
                log.debug("Thread2 read value: " + value);
                // Thread2通过CAS修改value值为1
                if (atomicInteger.compareAndSet(value, 1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }

在这里插入图片描述

ABA问题的解决方案

数据库有个锁称为乐观锁，是一种基于数据版本实现数据同步的机制，每次修改一次数据，版本就会进行累加。
同样，Java也提供了相应的原子引用类AtomicStampedReference
在这里插入图片描述
reference即我们实际存储的变量，stamp是版本，每次修改可以通过+1保证版本唯一性。这样就可以保证每次修改后的版本也会往上递增。

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.LockSupport;

@Slf4j
public class AtomicStampedReferenceTest {

    public static void main(String[] args) {
        // 定义AtomicStampedReference    Pair.reference值为1, Pair.stamp为1
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1, 1);

        new Thread(() -> {
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread1 read value: " + value + ", stamp: " + stamp);

            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通过CAS修改value值为3
            if (atomicStampedReference.compareAndSet(value, 3, stamp, stamp + 1)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        }, "Thread1").start();

        new Thread(() -> {
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread2 read value: " + value + ", stamp: " + stamp);
            // Thread2通过CAS修改value值为2
            if (atomicStampedReference.compareAndSet(value, 2, stamp, stamp + 1)) {
                log.debug("Thread2 update from " + value + " to 2");

                // do something

                value = (int) atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                log.debug("Thread2 read value: " + value + ", stamp: " + stamp);
                // Thread2通过CAS修改value值为1
                if (atomicStampedReference.compareAndSet(value, 1, stamp, stamp + 1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        }, "Thread2").start();
    }
}

在这里插入图片描述
补充：AtomicMarkableReference可以理解为上面AtomicStampedReference的简化版，就是不关心修改过几次，仅仅关心是否修改过。因此变量mark是boolean类型，仅记录值是否有过修改。
在这里插入图片描述

lang20150928
关注
专栏目录
深入理解高并发编程
qq_67447208的博客
09-09 889
线程可以有效降低程序的开发和维护成本，同时提升复杂应用程序的性能。在服务器应用程序中，可以提升资源利用率以及系统吞吐率，线程还可以简化JVM的实现，垃圾收集器通常在一个或多个专门的线程中运行，在许多重要的Java应用中，都在一定程度生用到了线程。
并发编程之深入了解CAS
沮丧的南瓜
11-11 1124
文章目录一、什么是 CAS二、CAS应用三、CAS源码分析三、CAS缺陷四、ABA问题及其解决方案4.1 什么是ABA问题4.2 ABA问题的解决方案 一、什么是 CAS CAS（Compare And Swap，比较并交换），通常指的是这样一种原子操作：针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。 CAS 的逻辑用伪代码描述如下： if (value == expectedValue) { value = newValue; } 以上伪代码描述了一个
并发编程：CAS
csp732171109的博客
12-31 552
什么是CAS？ CAS，全称为 Compare and Swap，即比较-替换。这是一个由 CPU 硬件提供并实现的原子操作。 CAS 是一种有名的无锁（lock-free）算法。也是一种现代 CPU 广泛支持的 CPU 指令级的操作，只有一步原子操作，所以非常快。而且 CAS 避免了请求操作系统来裁定锁的问题，不用麻烦操作系统，直接在 CPU 内部就搞定了。CAS 的引入是为了解决 java 锁机制带来的性能问题。 Jdk5 增加了并发包 java.util.concurrent.*,其下面的类使用
【并发编程】原子操作的基础：CAS
qq_35436158的博客
01-13 262
一文了解原子操作的基础：CAS。知道cas是什么，如何用，原理是什么，直接用会有什么问题。
深入理解CAS
MindMrWang的blog
04-12 911
本文转自：https://blog.csdn.net/mine_song/article/details/70140596 但是好像这个链接也是转载的，我点进去他的链接，发现根本不是那篇文章！ 再将我看的那篇文章给的链接给出： 原文连接：http://blog.csdn.net/hechurui/article/details/49508473 如有侵权，请告知，立删！ 还有一篇写的Vo...
01-并发编程之深入理解JMM&并发三大特性（一）.pdf
10-27
在深入理解Java内存模型（JMM）及并发三大特性方面，我们需要先建立对多线程、共享内存模型、可见性、有序性和原子性的基础概念。Java内存模型是Java并发编程的核心，它定义了共享变量在多线程环境中的行为规则和...
深入分析Java并发编程之CAS
08-24
本文将深入探讨Java并发编程中的CAS机制及其在Java中的实现。 首先，CAS操作的原理是：在执行更新操作前，先比较当前变量的值是否与预期值相等，如果相等则更新，否则不做任何操作。这种乐观锁策略假设并发冲突较少...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
CAS的理解
小志的博客
11-17 529
目录1、CAS是什么2、Java中乐观锁和悲观锁是什么3、CAS存在的问题 1、CAS是什么 CAS（Compare And Swap），即：对值先进行比较，符合我们的预期之后再进行赋值操作。 CAS是一种基于乐观锁的操作。 CAS操作主要来说包含三个概念：内存位置、预期原值和待赋值的新值。如果内存地址里面的值与预期原值相同，则将该值修改为新值，否则就不会对其进行修改。所以，使用CAS的时候，是要配合无限循环来进行：“获取原值——>对比原值——>尝试赋值”的操作的。如果第一次循环发现原值不匹配
CAS理解
小虾的博客
12-13 284
一、概念 CAS：Compare and Swap，即比较再交换。CAS是乐观锁的一种实现方式。 对CAS的理解，CAS是一种无锁算法，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。CAS是CPU指令级的操作，只有一步原子操作 二、应用场景 乐观锁的适用场景于就是读多写少的场景。 若发生大量的线程...
Java并发之CAS原理学习篇
笃行
09-21 319
大厂常见面试题： 你了解CAS吗，请谈谈你对CAS的理解？ CAS 底层原理是如何实现的？ 谈谈对 UnSafe 的理解？ CAS 的缺点？ 原子类 AtomicInteger 的 ABA 问题谈一谈？原子更新引用知道吗？ 1.你了解CAS吗，请谈谈你对CAS的理解？ CAS全称：“Compare And Swap”，意思是比较并交换。对于并发控制而言，锁是一种悲观策略，会阻塞线程执行...
并发编程-CAS
03-10 545
说在前面的话 正如我开篇所说，我要整理一些java并发编程的学习文档，这一篇就是第二篇：java中的CAS。 这一篇主要说的CAS的原理，以及java中的CAS的一些应用吧！ 欢迎关注和点赞。 开整 CAS是个啥 CAS,compare and swap的缩写，中文翻译成比较并交换。 首先想说的就是：CAS只是一个思想，原理。 本身没有问题，也没有所谓的ABA问题，也没有所谓的乐观锁长时间占用资源的问题。这些问题都是因为我们使用CAS的方式导致的。 不信？看我细细道来… CAS描述起来大概是： 准备一个预期
并发编程中的CAS
天涯一隅的博客
01-22 1631
在Java中，锁在鬓发处理中占据了一席之地，但是使用锁有一个不好的地方，就是当一个线程获取不到锁时会被阻塞挂起，这会导致线程上下文的切换和重新调度开销。Java提供了非阻塞的volatile关键字来解决共享变量的可见性问题，这在一定程度上弥补了锁带来的开销问题，但是volatile只能保证共享变量的可见性，不能解决读——改——写等的原子性问题。CAS即Compare and Swap，是JDK提供...
并发编程07：CAS
最新发布
m0_66689823的博客
05-08 362
并发编程07：CAS
并发编程—CAS
qlxiaomage的专栏
02-27 185
CAS概念：比较并交换，CAS是一种原子操作，针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给这个变量赋一个新值。CAS可以看做是乐观锁的一种实现，Java原子类中的递增操作就是通过CAS自旋实现的。CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。
并发编程 之 CAS
Howinfun的博客
05-26 271
并发编程基础之CAS及JDK原子类
Java并发编程：探索CAS机制与Unsafe实践
Java并发编程之CAS是Java多线程编程中一种高级且复杂的同步技术，它全称为Compare and Swap (CAS)，这是一种乐观锁策略。与传统的synchronized和Lock等同步机制不同，CAS不预先获取锁，而是在线程尝试修改共享资源前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lang20150928

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值