什么是CAS?CAS的底层原理是什么？哪些场景会用到？

已于 2025-07-04 13:45:11 修改
阅读量915 收藏 7
点赞数 21
CC 4.0 BY-SA版权
文章标签： java spring
于 2025-07-04 13:44:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41765748/article/details/149115936

面试中回答 CAS（Compare-And-Swap） 的底层原理和应用场景时，可以采用 “概念 + 原理 + 代码 + 场景” 的结构化方式，既清晰又有深度。以下是一个参考回答：

🗣️ 标准回答模板

概念
CAS 是一种无锁算法，用于实现多线程环境下的原子操作。它的核心思想是：先比较变量的当前值是否等于预期值，如果相等则更新为新值，否则操作失败。整个过程由 CPU 硬件保证原子性。

底层原理

  1. 硬件支持：CAS 依赖 CPU 的原子指令（如 x86 的 cmpxchg 指令），这些指令在硬件层面保证了比较和交换操作的不可分割性。
  2. Java 实现：
    • 在 Java 中，sun.misc.Unsafe 类提供了 compareAndSwapInt、compareAndSwapObject 等本地方法，直接调用 CPU 的原子指令。
    • AtomicInteger、AtomicLong 等原子类通过 Unsafe 实现 CAS 操作。例如：

      java

      public final boolean compareAndSet(int expectedValue, int newValue) {
    return U.compareAndSwapInt(this, VALUE, expectedValue, newValue);
}

      其中 U 是 Unsafe 实例，VALUE 是变量的内存偏移量。

应用场景

  1. 原子类操作：AtomicInteger、AtomicBoolean 等，用于实现无锁计数器、状态标记。
    • 示例：

      java

      private AtomicInteger count = new AtomicInteger(0);
public void increment() {
    count.incrementAndGet(); // 底层用 CAS 实现
}
  2. 并发容器：ConcurrentHashMap、ConcurrentLinkedQueue 等，用 CAS 替代传统锁提升性能。
  3. 乐观锁：数据库更新时的冲突检测（如 version 字段），或分布式锁中的 SETNX 命令。
  4. 状态转换：确保资源只被初始化一次（如单例模式）：

    java

    private static final AtomicReference<Resource> INSTANCE = new AtomicReference<>();
public static Resource getInstance() {
    if (INSTANCE.get() == null) {
        INSTANCE.compareAndSet(null, new Resource());
    }
    return INSTANCE.get();
}

💡 加分回答（深入理解）

  • 与锁的对比：

    • 锁是悲观的，认为总会发生冲突，因此先加锁；
    • CAS 是乐观的，认为冲突很少，先尝试操作，失败后重试。
      因此，CAS 在低冲突场景下性能远高于锁，但高冲突时可能因频繁重试导致 CPU 耗尽。

  • ABA 问题：

    • 如果变量从 A→B→A，CAS 会误认为值未变。
    • 解决方案：使用 AtomicStampedReference 或 AtomicMarkableReference 附加版本号或标记位。
    • 用一个银行转账的案例演示如何用 AtomicStampedReference 解决 CAS 的 ABA 问题
    • 🌰 案例：银行账户转账
假设账户余额从 100 元转出 50 元，再转入 50 元，余额变回 100 元。如果直接用 CAS 操作，可能会忽略中间的转账操作。
import java.util.concurrent.atomic.AtomicInteger;

public class ABADemo {
    private static AtomicInteger balance = new AtomicInteger(100);

    public static void main(String[] args) throws InterruptedException {
        // 线程1：模拟正常转账
        Thread t1 = new Thread(() -> {
            int expected = balance.get();
            System.out.println("T1 准备转出50，预期余额: " + expected);
            
            // 模拟处理延迟
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
            
            if (balance.compareAndSet(expected, expected - 50)) {
                System.out.println("T1 转出成功，当前余额: " + balance.get());
            } else {
                System.out.println("T1 转出失败，余额已被修改");
            }
        });

        // 线程2：模拟异常操作（先转出再转入）
        Thread t2 = new Thread(() -> {
            try { Thread.sleep(200); } catch (InterruptedException e) {}
            
            // 转出50
            int expected1 = balance.get();
            if (balance.compareAndSet(expected1, expected1 - 50)) {
                System.out.println("T2 转出50，当前余额: " + balance.get());
            }
            
            // 转入50
            int expected2 = balance.get();
            if (balance.compareAndSet(expected2, expected2 + 50)) {
                System.out.println("T2 转入50，当前余额: " + balance.get());
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

      可能的输出结果：

    • T1 准备转出50，预期余额: 100
T2 转出50，当前余额: 50
T2 转入50，当前余额: 100
T1 转出成功，当前余额: 50  // ❌ 出现 ABA 问题：余额被错误地扣减了两次

      ✅ 使用 AtomicStampedReference 解决 ABA 问题

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

public class ABASolution {
    // 初始余额100，版本号0
    private static AtomicStampedReference<Integer> balance = 
        new AtomicStampedReference<>(100, 0);

    public static void main(String[] args) throws InterruptedException {
        // 线程1：模拟正常转账
        Thread t1 = new Thread(() -> {
            int[] stampHolder = new int[1];
            int expected = balance.get(stampHolder);
            int expectedStamp = stampHolder[0];
            System.out.println("T1 准备转出50，预期余额: " + expected);
            
            // 模拟处理延迟
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
            
            // 同时检查值和版本号
            if (balance.compareAndSet(expected, expected - 50, expectedStamp, expectedStamp + 1)) {
                System.out.println("T1 转出成功，当前余额: " + balance.getReference());
            } else {
                System.out.println("T1 转出失败，余额已被修改");
            }
        });

        // 线程2：模拟异常操作（先转出再转入）
        Thread t2 = new Thread(() -> {
            try { Thread.sleep(200); } catch (InterruptedException e) {}
            
            // 转出50（版本号+1）
            int[] stampHolder1 = new int[1];
            int expected1 = balance.get(stampHolder1);
            int stamp1 = stampHolder1[0];
            if (balance.compareAndSet(expected1, expected1 - 50, stamp1, stamp1 + 1)) {
                System.out.println("T2 转出50，当前余额: " + balance.getReference());
            }
            
            // 转入50（版本号再+1）
            int[] stampHolder2 = new int[1];
            int expected2 = balance.get(stampHolder2);
            int stamp2 = stampHolder2[0];
            if (balance.compareAndSet(expected2, expected2 + 50, stamp2, stamp2 + 1)) {
                System.out.println("T2 转入50，当前余额: " + balance.getReference());
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

      输出结果：

    • T1 准备转出50，预期余额: 100
T2 转出50，当前余额: 50
T2 转入50，当前余额: 100
T1 转出失败，余额已被修改  // ✅ 正确处理了 ABA 问题

      AtomicStampedReference 维护一个 值 + 版本号 的组合：

    • 每次修改时，版本号递增（即使值变回原来的值，版本号也不同）
    • CAS 操作需要同时匹配值和版本号，只有两者都符合预期才会成功
    • 关键方法： 
      // 获取当前值和版本号（通过数组传递）
int[] stampHolder = new int[1];
int value = reference.get(stampHolder);
int stamp = stampHolder[0];

// 原子性地比较并设置（需要同时匹配值和版本号）
reference.compareAndSet(
    expectedValue,  // 预期值
    newValue,       // 新值
    expectedStamp,  // 预期版本号
    newStamp        // 新版本号
);

  • 实际项目经验：

    • 例如在分布式缓存系统中，用 AtomicInteger 统计缓存命中率；
    • 在状态机设计中，用 AtomicBoolean 控制服务启停；
    • 在数据库操作中，用 CAS 实现乐观锁防止更新冲突。

🚫 避坑指南

  • 不要混淆概念：CAS 是一种无锁算法，而 synchronized 是基于锁的实现。
  • 不要忽略 ABA 问题：必须提到 ABA 问题及其解决方案。
  • 结合场景回答：如果面试官追问 “CAS 和 synchronized 怎么选？”，可以回答：
    “CAS 适用于读多写少、冲突少的场景（如计数器），而 synchronized 适用于写多读少、冲突频繁的场景。”
周勇政
关注
【并发】深度解析CAS原理与底层源码
金鳞踏雨
12-10 824
CAS全称是（Compare And Swap，比较并交换），通常指的是这样一种原子操作（针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值）CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，我们稍后要讲的Java原子类中的递增操作（i++）就通过CAS自旋实现的。 CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步！
【Java多线程】 CAS —— 一文了解CAS到底是什么
Moo_Lavender的博客
03-21 1058
学过多线程就会接触到并发，并发再多线程中的重要性不言而喻，在Java中还有并发包，里面实现了各种各样的方法来帮助我们解决多线程带来的各种问题。而要想读懂这些底层问题，CAS是绕不过的知识，大多底层都是以CAS来实现的。今天就带大家来学习CAS相关的知识。 CAS一、什么是CAS?二、为什么要有CAS三、CAS是怎么实现的？四、CAS有哪些应用？五、CAS存在的问题 一、什么是CAS? CAS:...
Java CAS无锁技术深度解析
拈花的专栏
10-17 2003
在看AQS代码的时候，看到它很多地方调用了unsafe.compareAndSwapInt这类方法，百度了一下得知这叫CAS无锁技术。 CAS原理深度分析 转自：https://blog.youkuaiyun.com/Hsuxu/article/details/9467651?utm_source=blogxgwz1。 CAS: Compare and Swap，翻译成比较并交换。 java.uti...
Java并发编程总结2——慎用CAS
weixin_30556959的博客
06-08 544
一、CAS和synchronized适用场景 1、对于资源竞争较少的情况，使用synchronized同步锁进行线程阻塞和唤醒切换以及用户态内核态间的切换操作额外浪费消耗cpu资源；而CAS基于硬件实现，不需要进入内核，不需要切换线程，操作自旋几率较少，因此可以获得更高的性能。 2、对于资源竞争严重的情况，CAS自旋的概率会比较大，从而浪费更多的CPU资源，效率低于synchronized。以...
对cas算法的理解
xiongxianze的博客
04-19 2306
cas算法主要关心3个值：内存值V，预期值A，要更新的新值B 如下图所示：注：t1，t2线程是同时更新同一变量56的值因为t1和t2线程都同时去访问同一变量56，所以他们会把主内存的值完全拷贝一份到自己的工作内存空间，所以t1和t2线程的预期值都为56。 假设t1在与t2线程竞争中线程t1能去更新变量的值，而其他线程都失败。（失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次发起尝试）
重量级锁和CAS的适用场景
快乐小咸鱼007的博客
10-29 628
明确点: CAS的线程都是活跃状态，相当于一直处于while(true)的状态 重量锁的线程处于阻塞或者睡眠的状态 并发量很高以及任务执行时间很长的方法/任务适用于重量级锁，此时使用CAS自旋前者导致CPU的负载过重，后者则CPU不必要的消耗，你执行时间这么长还让我在这一直自旋，你逗我呐？ 上面的反例即为CAS的适用场景，并发量CPU可以承受，且每一个任务的执行时间比较短 ...
CAS底层原理以及使用场景详解，包含重点知识（ABA、原子性问题、与synchronized区别等分析）
weixin_51201930的博客
02-24 2507
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、什么是CAS？二、CAS底层原理 前言 在讲解CAS前，我们先来看两个简单例子。 第一个例子，运用synchronized实现多线程同步 public class cas_test { public static void main(String[] args) throws Exception { A a = new A(); long startTime = System.cu
CAS 的使用场景 & CAS的ABA问题的优化 以及 synchronized 的三大优化
qq_62949535的博客
01-04 6277
CAS（Compare-And-Swap）,是比较和交换的意思,它是一条CPU并发原语，用于判断内存中某个位置的值是否为预期值,如果是则更改为新的值,这个过程是原子的.它包含了三个参数：V，A，B。V表示要读写的变量内存地址A表示旧的预期值B表示准备设置的新值。
什么是线程池？从底层源码入手，深度解析线程池的工作原理
NBA123456789123的博客
09-24 969
为了对多线程进行统一的管理，Java引入了线程池，它通过限制并发线程的数量、将待执行的线程放入队列、销毁空闲线程，来控制资源消耗，使线程更合理地运行，避免系统因为创建过多线程而崩溃。**管理线程数量：**它可以管理线程的数量,可以避免无节制的销毁、创建线程，导致额外的性格损耗、或者线程数超出系统负荷直至崩溃。**提高性能：**当有新的任务到来时，可以直接从线程池中取出一个空闲线程来执行任务，而不需要等待创建新线程，从而减少了响应时间。
揭秘CAS：深入理解与应用解析
热门推荐
张彦峰的博客
01-17 84万+
在并发编程中，Compare-And-Swap（CAS）机制作为一种无锁算法，凭借其高效性和避免线程阻塞的优势，受到广泛关注。CAS不仅在底层实现上有着重要地位，还在实际开发中发挥着关键作用。本文将从CAS的工作原理、在Java中的实现及其增强机制来回顾和加深理解一下CAS。
CAS机制专篇，超详细讲解！（比较与交换，compareAndSwap，CAS原理，Unsafe是什么？valueOffset是什么？CAS的缺点，CAS的应用场景，ABA问题，ABA问题的解决办法）
m0_49690461的博客
07-18 2146
CAS专篇 前言 ​ 日常编码过程中，基本不会直接用到 CAS 操作，都是通过一些JDK 封装好的并发工具类来使用的，在 java.util.concurrent 包下。但是面试时 CAS 还是个高频考点，所以呀，你还不得不硬着头皮去死磕一下这块的技能点，总比一问三不知强吧？ 一、为什么要用无锁？ ​ 我们一想到在多线程下保证安全的方式头一个要拎出来的肯定是锁，不管从硬件、操作系统层面都或多或少在使用锁。锁有什么缺点吗？当然有了，不然 JDK 里为什么出现那么多各式各样的锁，就是因为每一种锁都有其优劣势
CAS 原理
王坦的博客
04-16 381
1、什么是 CAS？ CAS：Compare and Swap，即比较再交换。 jdk5 增加了并发包 java.util.concurrent.*, 其下面的类使用 CAS 算法实现了区别于 synchronouse 同步锁的一种乐观锁。JDK 5 之前 Java 语言是靠 synchronized 关键字保证同步的，这是一种独占锁，也是是悲观锁。 **2、CAS 算法理解 ** 对 CAS 的...
CAS原理分析
和大黄的博客
02-26 1万+
一、锁机制 常用的锁机制有两种： 1、悲观锁：假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作。悲观锁的实现，往往依靠底层提供的锁机制；悲观锁会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。 2、乐观锁：假设不会发生并发冲突，每次不加锁而是假设没有冲突而去完成某项操作，只在提交操作时检查是否违反数据完整性。如果因为冲突失败就重试，直到成功为止。乐观锁大多是基于数据
cas无法使用_「漫画」CAS原理分析！无锁原子类也能解决并发问题
weixin_39553705的博客
11-28 156
在漫画并发编程系统博文中，我们讲了N篇关于锁的知识，确实，锁是解决并发问题的万能钥匙，可是并发问题只有锁能解决吗？今天要出场一个大BOSS：CAS无锁算法，可谓是并发编程核心中的核心！温故首先我们再回顾一下原子性问题的原因，参考【漫画】JAVA并发编程 如何解决原子性问题。两个线程同时把count=0加载到自己的工作内存，线程B先执行count++操作，此时主内存已经变化成了1，但是线程A依旧以为...
CAS原理
qq_33440853的博客
10-10 191
CAS原理CAS是什么CAS使用CAS原理CAS应用如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 CAS是什么 CAS全称compareAndSwap,比较和...
读写屏障底层原理
最新发布
03-28
### 读写屏障的底层实现原理 #### 硬件同步机制概述 现代计算机体系结构中，多核处理器的存在使得多个线程可能同时访问共享资源。为了确保数据一致性，硬件提供了多种同步机制来控制内存访问顺序。其中，内存屏障...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值