CAS（Compare-and-Swap）详解

最新推荐文章于 2025-04-04 18:21:10 发布

·云扬·

最新推荐文章于 2025-04-04 18:21:10 发布

阅读量963

点赞数 19

分类专栏： Java # JUC 文章标签： java 开发语言笔记学习

本文链接：https://blog.youkuaiyun.com/gaosw0521/article/details/143931743

版权

Java 同时被 2 个专栏收录

166 篇文章

订阅专栏

JUC

44 篇文章

订阅专栏

在并发编程中，保证操作的原子性是一个重要的问题。常见的做法是使用锁，但锁的开销较大，且容易导致死锁等问题。CAS（Compare-and-Swap）是一种乐观锁的实现方式，它通过无锁的原子操作来保证线程安全。

1 乐观锁与悲观锁

在并发编程中，锁是一种常见的同步机制，用于确保多个线程对共享资源的访问是安全的。锁可以从不同的角度进行分类，例如偏向锁、轻量级锁、重量级锁等。乐观锁和悲观锁也是一种常见的分类方式。

1.1 悲观锁

悲观锁总是假设每次访问共享资源时会发生冲突，因此必须对每次数据操作加上锁，以保证临界区的程序同一时间只能有一个线程在执行。悲观锁的典型代表是 synchronized 关键字和 ReentrantLock。

悲观锁的工作原理如下：

获取锁：线程在进入临界区之前，必须先获取锁。如果锁已经被其他线程持有，当前线程将被阻塞，直到锁被释放。
执行临界区代码：线程获取锁后，可以安全地执行临界区代码。
释放锁：线程执行完临界区代码后，释放锁，以便其他线程可以获取锁并执行临界区代码。

悲观锁的优点是简单易用，能够有效避免数据竞争问题。但其缺点也很明显，频繁的加锁和解锁操作会导致性能开销较大，尤其是在高并发场景下，可能会导致线程频繁阻塞和唤醒，影响系统性能。

1.2 乐观锁

乐观锁则持相反的观点，它总是假设对共享资源的访问没有冲突，线程可以不停地执行，无需加锁也无需等待。一旦多个线程发生冲突，乐观锁通常使用一种称为 CAS（Compare-and-Swap）的技术来保证线程执行的安全性。

乐观锁的工作原理如下：

无锁执行：线程在执行过程中不需要获取锁，直接对共享资源进行操作。
冲突检测：在更新共享资源时，通过 CAS 操作来检测是否有其他线程已经修改了共享资源。如果检测到冲突，当前线程可以选择重试操作，或者采取其他策略。
重试或放弃：如果 CAS 操作失败，说明有其他线程已经修改了共享资源，当前线程可以选择重试操作，或者放弃操作。

乐观锁的优点是避免了频繁的加锁和解锁操作，减少了线程阻塞和唤醒的开销，适用于“读多写少”的场景。但其缺点是如果冲突频繁发生，重试操作会导致性能下降。

1.3 乐观锁与悲观锁的适用场景

乐观锁适用于“读多写少”的环境，避免频繁加锁影响性能。例如，在数据库中使用乐观锁来处理并发更新操作。
悲观锁适用于“写多读少”的环境，避免频繁失败和重试影响性能。例如，在高并发的写操作场景中，使用悲观锁可以确保数据的一致性。

2 CAS 的基本概念

CAS 全称为“比较并交换”（Compare And Swap），是一种无锁的原子操作。CAS 操作包含三个值：

V：要更新的变量（var）
E：预期值（expected）
N：新值（new）

CAS 的操作过程如下：

判断 V 是否等于 E，如果等于，将 V 的值设置为 N；
如果不等，说明已经有其他线程更新了 V，于是当前线程放弃更新，什么都不做。

这里的预期值 E 本质上指的是“旧值”。

当多个线程同时使用 CAS 操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。

3 CAS 的实现原理

在 Java 中，CAS 操作是通过 Unsafe 类来实现的。Unsafe 类提供了一些 native 方法，用于执行底层的 CAS 操作。例如：

boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
boolean compareAndSwapInt(Object o, long offset, int expected, int x);
boolean compareAndSwapLong(Object o, long offset, long expected, long x);

Unsafe 对 CAS 的实现是通过 C++ 实现的，这些方法的具体实现依赖于操作系统和 CPU。在 Linux 的 X86 架构下，CAS 操作主要通过 cmpxchgl 指令来完成。

CMPXCHG是“Compare and Exchange”的缩写，它是一种原子指令，用于在多核/多线程环境中安全地修改共享数据。CMPXCHG在很多现代微处理器体系结构中都有，例如Intel x86/x64体系。对于32位操作数，这个指令通常写作CMPXCHG，而在64位操作数中，它被称为CMPXCHG8B或CMPXCHG16B。

4 CAS 与原子操作

JDK 提供了一些用于原子操作的类，位于 java.util.concurrent.atomic 包中。例如：

AtomicInteger
AtomicLong
AtomicReference

这些类通过 CAS 操作来实现原子性。以 AtomicInteger 的 getAndAdd(int delta) 方法为例：

public final int getAndAdd(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta);
}

这里的 unsafe 其实就是一个Unsafe对象：

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();

getAndAddInt 方法的实现如下：

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}

在这个方法中，首先通过 getIntVolatile 获取当前值，然后通过 compareAndSwapInt 进行 CAS 操作。如果 CAS 操作失败，则继续循环重试，直到成功为止。

5 CAS 的三大问题

尽管 CAS 提供了一种有效的同步手段，但也存在一些问题：

ABA 问题：一个值原来是 A，变成了 B，又变回了 A。CAS 检查不出这种变化，但实际上值被更新了两次。解决方法是使用 AtomicStampedReference，通过增加版本号或时间戳来解决 ABA 问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果二者都相等，才使用 CAS 设置为新的值和标志。
长时间自旋：CAS 多与自旋结合，如果自旋 CAS 长时间不成功，会占用大量的 CPU 资源。解决方法是让 JVM 支持处理器提供的 pause 指令，让自旋失败时 CPU 睡眠一小段时间再继续自旋。
多个共享变量的原子操作：CAS 只能保证一个共享变量的原子操作。解决方法有两种：使用 AtomicReference 类保证对象之间的原子性，或者使用锁来保证多个共享变量的原子操作。