深入浅出：Java面试中的CAS技巧

最新推荐文章于 2026-08-20 14:41:22 发布

原创最新推荐文章于 2026-08-20 14:41:22 发布 · 965 阅读

17 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

互联网大厂Java面试题合集（超猛）

文章目录

深入浅出：Java面试中的CAS技巧 ?

深入浅出：Java面试中的CAS技巧 ?

大家好！我是都叫闫工，今天要聊的是一个 Java 面试中经常被问到的“硬核”知识点——CAS（Compare-And-Swap）。这个知识点看似简单，但其实里面有很多细节和应用场景，掌握好了它不仅能在面试中拿到高分，还能在工作中解决很多实际问题。

什么是 CAS？

CAS 是一种乐观锁机制，全称为 “比较并交换”（Compare And Swap）。它的核心思想是：我先检查一下变量的值是否符合预期，如果符合，我就把它修改成新的值；如果不符，那就说明有其他线程已经修改过了，这时候就需要重新尝试或者采取其他措施。

简单来说，CAS 有点像“我要买一杯咖啡，但前提是店里的拿铁还有货。如果有，我买下它；如果没有，我就只能喝奶茶了。”

在 Java 中，CAS 的实现主要依赖于 java.util.concurrent.atomic 包中的类，比如 AtomicInteger、AtomicLong 等。

CAS 的基本原理

CAS 的核心是通过硬件指令（通常是 CPU 提供的原子操作）来实现无锁编程。Java 通过调用底层的 Unsafe 类的方法来完成这个过程。具体来说，CAS 包含三个参数：

内存位置：即要操作的变量。
预期值：我预设的旧值。
新值：如果内存位置的值等于预期值，那么我就把它改成新值。

用代码表示就是：

public boolean compareAndSet(int expectedValue, int newValue) {
    // 实际实现会调用 Unsafe 的 compareAndSwapInt 方法
    return unsafe.compareAndSwapInt(this, valueOffset, expectedValue, newValue);
}

这个方法的返回值是一个布尔值，表示操作是否成功。

乐观锁 vs 悲观锁

在聊 CAS 之前，我们先简单了解一下乐观锁和悲观锁的区别。这有助于我们更好地理解 CAS 的应用场景。

乐观锁：假设并发情况下不会发生冲突，所以在执行操作时不需要加锁。如果发现冲突，再进行处理。
悲观锁：假设并发情况下肯定会发生冲突，所以在执行任何操作之前都会先加锁。

CAS 属于乐观锁的一种实现方式，因为它不依赖传统的加锁机制，而是通过不断尝试来完成操作。

CAS 的应用场景

1. 并发控制中的原子操作

CAS 最常见的应用场景是实现原子操作。例如，在高并发场景下，我们需要确保某个变量的修改是原子性的。

示例：用 CAS 实现一个自增计数器

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        int current;
        do {
            current = count.get();
        } while (!count.compareAndSet(current, current + 1));
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        // 启动多个线程同时调用 increment 方法
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(counter::increment);
            thread.start();
        }
    }
}

在这个例子中，AtomicInteger 的 compareAndSet 方法会不断尝试将当前值加 1，直到操作成功。这样就能保证计数器的自增是原子性的。

2. 实现无锁数据结构

CAS 还可以用来实现一些无锁的数据结构，比如无锁队列、无锁堆等。这种数据结构在高并发场景下性能非常优秀。

示例：用 CAS 实现一个简单的无锁栈

import java.util.concurrent.atomic.AtomicReference;

public class LockFreeStack<T> {
    private AtomicReference<Node<T>> top = new AtomicReference<>();

    private static class Node<T> {
        T value;
        Node<T> next;

        public Node(T value) {
            this.value = value;
        }
    }

    public void push(T value) {
        Node<T> newNode = new Node<>(value);
        Node<T> oldTop;
        do {
            oldTop = top.get();
            newNode.next = oldTop; // 将新节点指向旧栈顶
        } while (!top.compareAndSet(oldTop, newNode));
    }

    public T pop() {
        Node<T> oldTop;
        do {
            oldTop = top.get();
            if (oldTop == null) { // 栈为空
                return null;
            }
        } while (!top.compareAndSet(oldTop, oldTop.next));
        return oldTop.value;
    }

    public static void main(String[] args) {
        LockFreeStack<String> stack = new LockFreeStack<>();
        stack.push("A");
        stack.push("B");
        System.out.println(stack.pop()); // 输出 B
        System.out.println(stack.pop()); // 输出 A
    }
}

这个例子通过 AtomicReference 和 CAS 实现了一个简单的无锁栈。每次入栈和出栈操作都通过 compareAndSet 来保证原子性。

CAS 的优缺点

优点

高并发性能：CAS 是基于乐观锁的实现，避免了传统加锁机制带来的阻塞问题，因此在低冲突场景下性能非常优秀。
无锁设计：不需要依赖操作系统提供的互斥锁，减少了系统调用的开销。
简单易懂：实现逻辑相对简单，容易理解和维护。

缺点

ABA 问题：CAS 只检查值是否等于预期值，但如果某个变量被改成了其他值，再改回来，就会导致误判。例如：
- 初始值是 A。
- 线程 1 读取到 A，并准备修改为 B。
- 线程 2 把 A 改成了 B，然后再改回了 A。
- 线程 1 检查到当前值还是 A，就继续执行，导致错误。

解决方案：使用带有版本号的 CAS

通过在变量中加入版本号，每次修改都会增加版本号，这样就能避免ABA问题。

import java.util.concurrent.atomic.AtomicStampedReference;

public class ABADemo {
    private AtomicStampedReference<Integer> stampedRef = new AtomicStampedReference<>(0, 0);

    public void fixABA() {
        int value = stampedRef.getReference();
        int stamp = stampedRef.getStamp();

        // 线程 1 尝试修改
        boolean success = stampedRef.compareAndSet(value, 1, stamp, stamp + 1);
        if (success) {
            System.out.println("线程 1 修改成功");
        } else {
            System.out.println("线程 1 修改失败，重试");
        }

        // 线程 2 尝试修改
        value = stampedRef.getReference();
        stamp = stampedRef.getStamp();
        success = stampedRef.compareAndSet(value, 0, stamp, stamp + 1);
        if (success) {
            System.out.println("线程 2 修改成功");
        } else {
            System.out.println("线程 2 修改失败，重试");
        }
    }

    public static void main(String[] args) {
        ABADemo demo = new ABADemo();
        demo.fixABA();
    }