当前位置：首页 > news >正文

深入理解 CAS：无锁编程的核心基石

news 2025/8/20 7:36:42

什么是 CAS？

CAS 的工作原理

Java 中的 CAS 实现

CAS 的优势

CAS 的局限性

1. ABA 问题

2. 自旋开销

3. 只能保证单个变量的原子操作

CAS 的典型应用场景

总结

在并发编程领域，我们常常面临一个核心问题：如何在多线程环境下安全地修改共享资源，同时避免传统锁机制带来的性能开销？今天我们要探讨的 CAS（Compare-And-Swap，比较并交换）正是解决这个问题的关键技术，它是许多无锁数据结构和并发工具的底层实现基础。

什么是 CAS？

CAS 是一种原子操作，它包含三个操作数：

内存位置（V）：需要修改的共享变量在内存中的地址
预期原值（A）：线程在操作前读取到的变量值
新值（B）：线程想要将变量修改为的值

CAS 操作的执行逻辑非常简单：当且仅当内存位置 V 中的值等于预期原值 A 时，才会将该位置的值更新为新值 B；否则不做任何操作。整个过程是原子的，不会被其他线程中断。

用伪代码表示如下：

boolean compareAndSwap(int[] memory, int index, int expected, int newValue) {if (memory[index] == expected) {memory[index] = newValue;return true; // 操作成功}return false; // 操作失败
}

CAS 的工作原理

CAS 操作的原子性通常是通过硬件指令实现的（如 x86 架构的 cmpxchg 指令），这使得它能够在不使用锁的情况下保证并发安全性。

当多个线程同时对同一个共享变量执行 CAS 操作时，只有一个线程会成功，其他线程会发现内存中的实际值与自己的预期值不符而操作失败。失败的线程可以选择重试、放弃或执行其他操作。

这种机制相比传统的锁机制有一个显著优势：失败者不会被阻塞，这就避免了线程上下文切换和调度的开销，在高并发场景下可能带来显著的性能提升。

Java 中的 CAS 实现

在 Java 中，CAS 操作主要通过 sun.misc.Unsafe 类实现，这个类提供了一系列 native 方法封装了底层的 CAS 指令。我们熟悉的 java.util.concurrent.atomic 包下的原子类（如 AtomicInteger、AtomicLong 等）都是基于 Unsafe 类的 CAS 操作实现的。

以 AtomicInteger 的 incrementAndGet() 方法（原子自增）为例，其内部实现大致如下：

public class AtomicInteger extends Number implements java.io.Serializable {private static final long serialVersionUID = 6214790243416807050L;// 存储实际值的变量，使用 volatile 保证可见性private volatile int value;// 获取 Unsafe 实例private static final Unsafe unsafe = Unsafe.getUnsafe();// value 变量在内存中的偏移量private static final long valueOffset;static {try {// 获取 value 字段的内存偏移量valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));} catch (Exception ex) { throw new Error(ex); }}public final int incrementAndGet() {// 循环执行 CAS 操作直到成功return unsafe.getAndAddInt(this, valueOffset, 1) + 1;}
}

而 Unsafe 类的 getAndAddInt() 方法内部其实是一个自旋 CAS 操作：

public final int getAndAddInt(Object o, long offset, int delta) {int v;do {// 获取当前值v = getIntVolatile(o, offset);// 执行 CAS 操作，如果失败则重试} while (!compareAndSwapInt(o, offset, v, v + delta));return v;
}

这段代码的逻辑是：不断尝试将变量的值从当前值 v 更新为 v + delta，直到 CAS 操作成功为止。这就是所谓的自旋 CAS。

CAS 的优势

非阻塞性：失败的线程不会被挂起，而是可以立即重试或执行其他操作，减少了线程切换的开销。
粒度更细：可以精确到对单个变量的操作，而锁通常会锁定更大的代码块。
天然死锁免疫：由于没有锁的概念，也就不存在死锁问题。
高性能：在低冲突场景下，CAS 操作的性能远高于锁机制，因为它避免了操作系统内核态的调度。

CAS 的局限性

尽管 CAS 是一种强大的并发控制机制，但它也有一些固有的局限性：

1. ABA 问题

这是 CAS 最著名的问题。假设一个变量原值为 A，线程 1 读取到 A 后准备将其更新为 B；此时线程 2 先将变量从 A 改为 C，再改回 A。当线程 1 执行 CAS 操作时，会发现变量的值仍然是 A，从而误以为没有被修改而成功更新为 B。

在某些场景下，这种情况可能导致错误。例如在链表操作中，节点的值虽然没变，但节点的实际状态可能已经发生了变化。

解决 ABA 问题的常用方法是引入版本号，每次修改都更新版本号，CAS 操作时不仅比较值，还要比较版本号。

2. 自旋开销

当并发冲突激烈时，失败的线程会不断重试 CAS 操作，这会浪费大量 CPU 资源。极端情况下，某个线程可能一直抢不到锁，导致饥饿现象。

为了缓解这个问题，一些实现会采用自适应自旋策略，即根据历史重试情况动态调整自旋次数。

3. 只能保证单个变量的原子操作

CAS 只能对单个变量执行原子操作，无法直接实现多个变量的原子性操作。如果需要对多个变量进行原子操作，仍然需要使用锁或者其他机制。

CAS 的典型应用场景

原子类：java.util.concurrent.atomic 包下的所有类都基于 CAS 实现，如 AtomicInteger、AtomicReference 等。
并发容器：许多并发容器的实现都用到了 CAS，如 ConcurrentLinkedQueue、ConcurrentHashMap（JDK 1.8+）等。
锁机制：一些高级锁机制的实现也依赖 CAS，如 ReentrantLock 中的公平锁和非公平锁的获取。
计数器：在高并发场景下，使用 CAS 实现的计数器比同步锁效率更高。
乐观锁：数据库中的乐观锁实现思想与 CAS 类似，通过版本号控制并发修改。