什么是 CAS（Compare-and-Swap）操作？它在并发编程中有什么作用？

八股文_Java并发基础题 0 3

参考回答

CAS（Compare-And-Swap） 是一种无锁操作，用于实现多线程并发控制中的原子性操作。它的核心思想是：比较并交换，即在更新变量时，先比较变量的当前值是否与期望值一致，如果一致，则将变量更新为新值；否则，不做任何操作，并可以重试。

在并发编程中，CAS 是实现 无锁算法（Lock-Free Algorithm） 的基础，避免了传统加锁机制可能带来的线程阻塞问题。

详细讲解与拓展

1. CAS 的工作原理

CAS 操作通常涉及以下三个值：

变量的内存值（V）：当前变量在主内存中的值。
期望值（E）：线程认为变量当前应该具有的值。
新值（N）：线程希望将变量更新为的值。

步骤：

比较 V和 E是否相等：

如果相等，将变量的值更新为 N。
如果不相等，则不更新，通常重试或失败。

这个过程是原子性操作，保证了线程安全。

2. CAS 的代码示例

在 Java 中，java.util.concurrent.atomic 包中的类（如 AtomicInteger）通过 CAS 操作实现。

示例代码：

import java.util.concurrent.atomic.AtomicInteger;

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

        boolean updated = atomicInteger.compareAndSet(5, 10); // 如果当前值是 5，则更新为 10
        System.out.println("Updated: " + updated + ", New Value: " + atomicInteger.get()); // 输出 Updated: true, New Value: 10

        updated = atomicInteger.compareAndSet(5, 15); // 尝试更新为 15，但当前值已不是 5
        System.out.println("Updated: " + updated + ", New Value: " + atomicInteger.get()); // 输出 Updated: false, New Value: 10
    }
}

输出解释：

第一次 compareAndSet(5, 10) 成功，因为内存值与期望值相等。
第二次 compareAndSet(5, 15) 失败，因为内存值不再是 5。

3. CAS 的作用

实现线程安全的无锁操作：
- CAS 不需要像 synchronized 或 ReentrantLock 那样加锁，避免了线程阻塞和上下文切换。
- 常用于计数器、队列等高性能并发场景。
提高并发性能：
- 在高并发环境下，CAS 操作的性能通常优于锁机制，因为它避免了线程的阻塞和竞争。
用于实现 Atomic 类：
- Java 提供的 AtomicInteger、AtomicLong、AtomicReference 等类都基于 CAS 操作实现原子性。

4. CAS 的缺点

ABA 问题：

如果变量值从 A 变为 B，然后又变回 A，CAS 无法察觉这种变化。

解决方法：可以引入版本号（如 AtomicStampedReference），在每次修改时增加版本号来避免。

示例：

import java.util.concurrent.atomic.AtomicStampedReference;

public class ABASolution {
   public static void main(String[] args) {
       AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(100, 1);

       int initialStamp = ref.getStamp();
       Integer initialValue = ref.getReference();

       // 修改值
       ref.compareAndSet(100, 200, initialStamp, initialStamp + 1); // 更新为 200，版本号加 1

       // 再次尝试恢复到 100
       boolean success = ref.compareAndSet(200, 100, initialStamp, initialStamp + 2); // 失败，版本号不匹配
       System.out.println("CAS success: " + success); // 输出 false
   }
}

自旋消耗 CPU：

如果多个线程频繁重试 CAS 操作，可能会导致 CPU 资源浪费。
优化方法：将 CAS 与适当的退让（如 Thread.yield() 或 sleep）结合使用，降低自旋的开销。

无法解决复杂操作的原子性：

CAS 只能处理单个变量的原子性操作，不能直接处理多个变量的原子性更新。
解决方法：可以结合锁机制或通过 AtomicReference 封装对象。

5. CAS 的使用场景

高性能计数器： 如 AtomicInteger 实现的线程安全递增计数器：

AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet(); // 原子递增

无锁队列： 如 ConcurrentLinkedQueue，通过 CAS 操作实现入队和出队的线程安全。
线程池： java.util.concurrent 中的线程池使用 CAS 来更新线程的状态。
状态标志： 用于高效地更新线程的运行状态或中断标志。

6. CAS 的底层实现

在 Java 中，CAS 操作依赖于 Unsafe 类 的本地方法，例如：

public final native boolean compareAndSwapInt(Object obj, long offset, int expected, int newValue);

Unsafe 类直接调用处理器提供的原子指令（如 CMPXCHG）实现。

总结

CAS（Compare-And-Swap） 是一种无锁的线程安全机制，通过比较内存中的值是否等于预期值，然后进行更新，来保证操作的原子性。它在并发编程中具有以下特点：

优点：高效，无需锁，避免线程阻塞。
缺点：可能存在 ABA 问题和高自旋开销。

适用场景包括高性能计数器、无锁队列等。虽然 CAS 是现代并发编程的重要基础，但在需要更复杂的操作时，可能需要结合其他工具（如锁）使用。