面试题：什么是 Java 的 CAS（Compare-And-Swap）操作？

CAS（Compare-And-Swap） 是一种并发编程中的原子操作，用于实现无锁的线程安全操作。它是现代多核处理器提供的一种硬件指令，Java 通过 sun.misc.Unsafe 类或 java.util.concurrent.atomic 包中的原子类（如 AtomicInteger、AtomicLong 等）来支持 CAS 操作。

1. CAS 的基本概念

CAS 操作 包含三个操作数：
- 内存位置（V）：需要更新的变量。
- 期望值（A）：变量当前的值。
- 新值（B）：变量将要更新的值。
CAS 的执行过程：
1. 检查内存位置 V 的值是否等于期望值 A。
2. 如果相等，则将内存位置 V 的值更新为新值 B。
3. 如果不相等，则不进行任何操作。
CAS 的返回值：
- 返回 true：表示更新成功。
- 返回 false：表示更新失败（说明其他线程已经修改了值）。

2. CAS 的特点

原子性：
- CAS 操作是硬件级别的原子操作，不会被线程调度打断。
无锁：
- 通过 CAS 可以实现无锁的线程安全操作，避免了锁带来的性能开销。
乐观锁：
- CAS 是一种乐观锁机制，假设没有竞争，只有在更新时检查是否发生冲突。
ABA 问题：
- CAS 可能会遇到 ABA 问题，即一个值从 A 变为 B，又变回 A，CAS 无法感知到中间的变化。
- 解决方法：使用版本号或时间戳（如 AtomicStampedReference）。

3. CAS 的实现

Java 中的 CAS：
- Java 通过 sun.misc.Unsafe 类提供 CAS 操作，但 Unsafe 类不推荐直接使用。
- 更推荐使用 java.util.concurrent.atomic 包中的原子类，如 AtomicInteger、AtomicLong 等。

示例代码：

import java.util.concurrent.atomic.AtomicInteger;

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

        // CAS 操作：如果当前值是 0，则更新为 1
        boolean success = atomicInt.compareAndSet(0, 1);
        System.out.println("CAS success: " + success); // 输出 true
        System.out.println("Current value: " + atomicInt.get()); // 输出 1

        // CAS 操作：如果当前值是 0，则更新为 2（会失败）
        success = atomicInt.compareAndSet(0, 2);
        System.out.println("CAS success: " + success); // 输出 false
        System.out.println("Current value: " + atomicInt.get()); // 输出 1
    }
}

4. CAS 的应用场景

原子类：
- AtomicInteger、AtomicLong、AtomicReference 等原子类都是基于 CAS 实现的。
无锁数据结构：
- 如无锁队列、无锁栈等。
并发工具：
- 如 ReentrantLock、CountDownLatch 等并发工具的内部实现也使用了 CAS。

5. CAS 的优缺点

优点：
- 高性能：避免了锁的开销，适合高并发场景。
- 无死锁：由于无锁，不会出现死锁问题。
缺点：
- ABA 问题：需要额外的手段（如版本号）来解决。
- 自旋开销：如果竞争激烈，CAS 可能会长时间自旋，消耗 CPU 资源。
- 只能保证一个变量的原子性：无法直接支持多个变量的原子操作。

6. CAS 的底层实现

硬件支持：
- CAS 操作依赖于 CPU 的硬件指令，如 x86 架构的 CMPXCHG 指令。
Java 实现：
- Java 通过 Unsafe 类调用底层的 CAS 指令。
- 例如，AtomicInteger 的 compareAndSet 方法最终会调用 Unsafe 的 compareAndSwapInt 方法。

7. CAS 与锁的对比

特性	CAS	锁（如 `synchronized`）
实现方式	无锁，基于硬件指令	基于 JVM 的锁机制
性能	高并发下性能更好	高并发下性能较差
适用场景	适合读多写少的高并发场景	适合写多读少的场景
复杂性	实现复杂，需要处理 ABA 问题	实现简单，易用
死锁风险	无死锁风险	可能产生死锁