Java并发编程：CAS原理与应用实践-代码聚汇网

Java并发编程：CAS原理与应用实践

柳桃的小久久·2026-08-12·阅读 23 GEO检测（免费）

Java并发CAS原子操作

|难度：普通|阅读约 14 分钟

1. 为什么CAS是Java并发的基石

在Java并发编程的世界里，CAS（Compare-And-Swap）就像是一把精巧的瑞士军刀。我第一次真正理解它的价值，是在处理一个高并发的计数器场景时。当时使用synchronized关键字虽然能保证线程安全，但性能监控显示线程阻塞时间占总处理时长的30%以上。改用AtomicInteger的CAS实现后，吞吐量直接提升了4倍。

CAS的本质是一条CPU原子指令，它包含三个操作数：内存位置(V)、预期原值(A)和新值(B)。当且仅当V的值等于A时，处理器才会用B更新V的值，否则不执行更新。整个比较和交换过程是一个不可分割的原子操作，这使其成为无锁算法的基础。

关键提示：CAS的原子性是由硬件层面保证的，现代CPU通常通过锁定缓存行或总线的方式实现，这比操作系统级别的锁要轻量得多

在Java中，CAS操作主要通过sun.misc.Unsafe类的compareAndSwapXXX方法实现，但我们通常使用java.util.concurrent.atomic包下的原子类（如AtomicInteger）来间接操作。这些原子类就像是线程安全的包装器，内部通过CAS实现各种原子操作。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. CAS的典型应用场景解析

2.1 计数器实现的艺术

最经典的CAS应用莫过于原子计数器。假设我们要实现一个多线程环境下的点赞计数器：

java复制public class LikeCounter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void addLike() {
        int oldValue;
        int newValue;
        do {
            oldValue = count.get();
            newValue = oldValue + 1;
        } while (!count.compareAndSet(oldValue, newValue));
    }
}

这段代码展示了CAS的典型使用模式：循环重试。当多个线程同时尝试修改计数器时，失败的线程不会阻塞，而是立即重试。这种乐观锁策略在低冲突场景下性能极佳。

2.2 无锁栈的实现陷阱

CAS也可用于构建更复杂的数据结构。比如无锁栈的实现：

java复制public class ConcurrentStack<E> {
    private AtomicReference<Node<E>> top = new AtomicReference<>();
    
    public void push(E item) {
        Node<E> newHead = new Node<>(item);
        Node<E> oldHead;
        do {
            oldHead = top.get();
            newHead.next = oldHead;
        } while (!top.compareAndSet(oldHead, newHead));
    }
    
    private static class Node<E> {
        final E item;
        Node<E> next;
        
        Node(E item) { this.item = item; }
    }
}

但这里隐藏着一个经典问题——ABA问题。假设线程1读取栈顶为A，准备将其替换为B。此时线程2弹出A，压入C，又压入A。当线程1执行CAS时，栈顶仍然是A，但实际上栈的状态已经改变。这在某些场景下会导致数据不一致。

3. CAS面试题深度剖析

3.1 经典ABA问题解决方案

针对ABA问题，Java提供了AtomicStampedReference和AtomicMarkableReference两个类。它们通过添加版本号或标记位来解决：

java复制AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);

// 线程1
int[] stampHolder = new int[1];
String initialRef = ref.get(stampHolder);
int initialStamp = stampHolder[0];

// 线程2修改了ref从A->B->A，并改变了stamp
ref.compareAndSet("A", "B", stampHolder[0], stampHolder[0]+1);
ref.compareAndSet("B", "A", stampHolder[0], stampHolder[0]+1);

// 线程1尝试更新
boolean success = ref.compareAndSet(initialRef, "C", initialStamp, initialStamp+1);

3.2 CAS与volatile的内存语义区别

面试中常被问及CAS和volatile的区别。关键差异在于：

volatile保证可见性和有序性，但不保证原子性
CAS同时保证原子性、可见性和有序性

比如i++操作：

volatile int i：多线程下仍会丢失更新
AtomicInteger i：CAS保证原子性

3.3 性能优化实战：LongAdder vs AtomicLong

在高争用环境下，传统的CAS实现会导致大量重试。Java 8引入了LongAdder，采用分段CAS策略：

java复制LongAdder counter = new LongAdder();
counter.increment(); // 内部使用Cell[]分散热点

// 最终结果需要求和
long total = counter.sum();

实测数据：在16线程并发下，LongAdder的吞吐量是AtomicLong的6倍，但读取结果时需要额外的sum()操作。

4. CAS的底层实现与JVM优化

4.1 HotSpot的CAS实现机制

在HotSpot虚拟机中，CAS操作最终会转化为平台相关的指令：

x86: LOCK CMPXCHG
ARM: LDREX/STREX指令对

通过Java的-XX:+PrintAssembly参数可以观察生成的汇编代码。例如AtomicInteger的compareAndSet()会生成类似如下的指令序列：

code复制lock cmpxchg dword ptr [r10],r11

CAS操作可能引发伪共享问题。当多个线程修改位于同一缓存行的不同变量时，会导致不必要的缓存失效。解决方法包括：

@Contended注解（Java 8+）
手动填充(Padding)

java复制class ContendedCounter {
    @sun.misc.Contended
    public volatile long value1 = 0;
    public volatile long value2 = 0;
}

4.3 JVM对CAS的优化策略

现代JVM会针对CAS操作进行多种优化：

循环展开：减少分支预测失败
延迟后退：冲突时增加随机延迟
自适应自旋：根据历史成功率调整自旋次数

5. 生产环境中的CAS实践

5.1 正确测量CAS的开销

使用JMH进行基准测试时，要注意CAS的成本与争用程度密切相关：

java复制@Benchmark
@Threads(4)
public void testAtomicIncrement(Blackhole bh) {
    bh.consume(atomicInteger.incrementAndGet());
}

测试结果显示：

无竞争时：约10ns/op
4线程竞争：约50ns/op
32线程竞争：约500ns/op

5.2 避免CAS的常见误用

过度乐观：在高争用场景下，CAS可能导致大量重试，此时传统的锁可能更合适
活锁风险：

java复制// 错误示例：可能产生活锁
while (!atomicInt.compareAndSet(old, new)) {
    old = atomicInt.get();
    new = calculateNew(old);
}

优先级反转：低优先级线程持有CAS资源可能导致高优先级线程空转

5.3 与锁的混合使用策略

最佳实践是采用分层策略：

首先尝试CAS（快速路径）
失败后使用轻量级锁
最后才考虑重量级锁

java复制public class HybridLock {
    private AtomicInteger state = new AtomicInteger(0);
    
    public void lock() {
        if (!state.compareAndSet(0, 1)) {
            synchronized(this) {
                while (state.get() != 0) {
                    try { wait(); } catch (InterruptedException e) {}
                }
            }
        }
    }
}

6. 从CAS看Java并发演进

6.1 Java各版本的CAS改进

Java 5：引入原子类
Java 7：优化底层CAS实现
Java 8：添加LongAdder等增强类
Java 9：VarHandle提供更灵活的CAS操作

6.2 VarHandle带来的新可能

VarHandle提供了比Atomic更灵活的CAS操作：

java复制class Point {
    private int x;
    
    private static final VarHandle X;
    static {
        try {
            X = MethodHandles.lookup()
                .findVarHandle(Point.class, "x", int.class);
        } catch (Exception e) { ... }
    }
    
    public void increment() {
        int oldValue;
        do {
            oldValue = (int) X.get(this);
        } while (!X.compareAndSet(this, oldValue, oldValue+1));
    }
}

6.3 未来趋势：硬件加速的CAS

新一代CPU开始提供更丰富的原子指令，如：

ARM的LSE（Large System Extensions）
x86的TSX（Transactional Synchronization Extensions）

这些硬件进步将进一步提升CAS的性能上限。