什么是 Java 的 CAS（Compare-And-Swap）操作？

回答

Java 中的 CAS（Compare-And-Swap，比较并交换）是一种原子操作，用于在多线程环境下实现线程安全的无锁编程。它通过硬件级别的指令支持，确保对共享变量的操作是原子的，避免使用显式锁带来的性能开销。CAS 是许多 Java 并发工具（如原子类）的核心机制。以下是详细说明：

定义

• 全称：Compare-And-Swap（比较并交换）。
• 作用：在不使用锁的情况下，原子性地更新变量值。
• 核心思想：
  • 比较当前值（内存中的值）与预期值（旧值），如果相等，则更新为新值；否则操作失败。
• 硬件支持：
  • 依赖 CPU 提供的原子指令，如 cmpxchg（x86 架构）。

工作原理

CAS 操作包含三个关键参数：

1. 内存位置（V）：要操作的变量所在的内存地址。
2. 预期值（A）：线程认为的当前值（旧值）。
3. 新值（B）：希望设置的新值。

• 执行步骤：

  1. 读取内存位置 V 的当前值。
  2. 比较当前值与预期值 A 是否相等。
  3. 如果相等，将 V 更新为新值 B，返回成功。
  4. 如果不相等，不做任何更新，返回失败。

• 伪代码：

  boolean CAS(V, A, B) {
      if (V == A) {
          V = B;
          return true;
      }
      return false;
  }
  

Java 中的实现

• 底层支持：
  • Java 通过 sun.misc.Unsafe 类提供 CAS 操作（如 compareAndSwapInt）。
  • Unsafe 调用本地方法（JNI），利用 CPU 的原子指令。
• 原子类中的 CAS：
  • java.util.concurrent.atomic 包中的类（如 AtomicInteger）封装了 CAS。
  • 示例方法：compareAndSet(int expect, int update)。

示例代码

使用 AtomicInteger 的 CAS：

import java.util.concurrent.atomic.AtomicInteger;

public class CASExample {
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int current;
            do {
                current = counter.get();
            } while (!counter.compareAndSet(current, current + 1));
            System.out.println("T1: " + counter.get());
        });

        Thread t2 = new Thread(() -> {
            int current;
            do {
                current = counter.get();
            } while (!counter.compareAndSet(current, current + 1));
            System.out.println("T2: " + counter.get());
        });

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

输出（可能顺序不同）：

T1: 1
T2: 2

优点

• 无锁：避免锁的上下文切换和线程阻塞开销。
• 高性能：在低争用场景下，CAS 效率高于锁。
• 简单性：适合简单原子操作（如计数器）。

缺点与问题

1. ABA 问题：
   • 描述：线程读取值 A，准备更新时值变为 B 又变回 A，CAS 认为未变而成功，但实际数据已改变。
   • 解决：使用 AtomicStampedReference 或 AtomicMarkableReference 引入版本号或标记。
   • 示例：
     • 初始 A=1，线程 1 读取 A=1，线程 2 修改为 B=2 再改回 A=1，线程 1 的 CAS 成功，但未察觉变化。
2. 自旋开销：
   • 高争用时，CAS 失败后需循环重试（自旋），可能消耗 CPU。
3. 功能限制：
   • 仅支持单变量操作，无法直接处理复杂逻辑。

使用场景

1. 计数器：
   • AtomicInteger.incrementAndGet() 使用 CAS 实现线程安全的递增。
2. 无锁数据结构：
   • 如无锁队列、栈的实现。
3. 状态标志：
   • AtomicBoolean 的 CAS 用于开关控制。

Java 中的应用

• 原子类：
  • AtomicInteger、AtomicLong、AtomicReference 等核心操作基于 CAS。
• 并发工具：
  • ConcurrentHashMap 的某些操作（如 putIfAbsent）使用 CAS。
• 线程池：
  • ThreadPoolExecutor 的状态管理（如线程计数）使用 CAS。

问题分析与知识点联系

“CAS 操作”是 Java 并发编程的无锁基础，与问题列表中的多个知识点相关：

1. Java 中的线程安全
   CAS 提供无锁的线程安全实现，替代锁机制。

2. Java 中的原子类
   AtomicInteger 等基于 CAS，是其典型应用。

3. Java 的累加器
   LongAdder 在高并发下优化了 CAS，通过分段减少争用。

4. Java 中的 ABA 问题
   CAS 的固有缺陷，需通过版本控制解决。

5. Java 中的锁优化
   CAS 是无锁优化的核心技术，与自旋锁相关。

总结来说，CAS 是 Java 并发编程中实现高效原子操作的关键机制，广泛应用于无锁数据结构和工具类。它通过硬件支持提供线程安全，但在高争用和复杂场景下需注意 ABA 问题和性能开销，是理解并发优化的重要知识点。