Java CAS原理和用法總結

更新時間：2026年01月12日 09:24:30 作者：看透也說透kevin

CAS（Compare And Swap）是一種無鎖的原子操作機制,通過一條CPU硬件指令（如x86架構的CMPXCHG指令）實現(xiàn),能保證操作的原子性,本文給大家介紹java CAS原理和用法,感興趣的朋友跟隨小編一起看看吧

一、CAS 原理

1. 核心思想

CAS 是一種無鎖的原子操作機制。它的核心思想是：我認為值應該是A，如果是，那我就把它改成B；如果不是A（說明被別人改過了），那我就不修改，然后可以選擇重試或放棄。

這個操作是作為一條CPU硬件指令實現(xiàn)的（在x86架構上是 CMPXCHG 指令），因此它能保證原子性，不會被線程調度打斷。

2. 操作模型

CAS 操作涉及三個操作數：

內存位置（V）
預期的原值（A）
新值（B）

偽代碼邏輯如下：

if (V == A) {
V = B;
return true;
} else {
return false;
}

但關鍵是，整個比較和交換的過程是一個不可分割的原子操作。

3. 工作流程

當一個線程想要更新一個變量時，它會：

獲取當前內存中的值，作為期望值 A。
計算出新值 B。
執(zhí)行 CAS 指令，判斷當前內存中的值是否還是 A。
- 如果是，說明沒有其他線程修改過，成功將值更新為 B。
- 如果不是，說明值已被其他線程修改，本次更新失敗。線程通常會重試整個操作（獲取新的當前值，計算新值，再次執(zhí)行CAS），直到成功為止。這種重試行為就是常見的自旋。

4. 優(yōu)點與缺點

優(yōu)點：
- 高性能：避免了重量級鎖（如 synchronized）帶來的線程阻塞、喚醒和上下文切換的開銷，在競爭不激烈的場景下性能極高。
- 避免死鎖：由于是無鎖操作，從根本上避免了死鎖問題。
缺點：
- ABA 問題：CAS 只檢查值是否變化，但如果一個值從 A 變成 B，又被改回 A，CAS 會誤以為它沒變。解決方案是使用版本號或標記（如 AtomicStampedReference）。
- 自旋開銷：在高競爭環(huán)境下，如果線程一直失敗重試，會長時間占用 CPU，消耗資源。
- 只能保證一個共享變量的原子操作：對于多個共享變量，CAS 無法保證原子性。但可以將它們合并成一個對象，使用 AtomicReference 來保證原子性。

二、Java 中的 CAS 用法

在 Java 中，你不能直接使用 CPU 指令。CAS 的能力是通過 sun.misc.Unsafe 類中的本地（Native）方法提供的。但通常，我們不會直接使用 Unsafe，而是使用 JD 在 java.util.concurrent.atomic 包下為我們封裝好的原子類。

1. 主要的原子類

基本類型：
- AtomicInteger：整型原子類
- AtomicLong：長整型原子類
- AtomicBoolean：布爾型原子類
數組類型：
- AtomicIntegerArray：整型數組原子類
- AtomicLongArray：長整型數組原子類
- AtomicReferenceArray：引用類型數組原子類
引用類型：
- AtomicReference：引用類型原子類
- AtomicMarkableReference：帶標記位的引用類型原子類（解決ABA問題的一種方式）
- AtomicStampedReference：帶版本號的引用類型原子類（解決ABA問題的標準方案）
字段更新器：
- AtomicIntegerFieldUpdater：基于反射，原子性地更新某個類的 volatile int 字段。
- AtomicLongFieldUpdater
- AtomicReferenceFieldUpdater

2. 核心方法

所有原子類都提供了基于 CAS 的核心方法：

boolean compareAndSet(int expect, int update)
- 這是最核心的方法！如果當前值等于期望值 expect，則原子地將值設置為 update，成功返回 true，失敗返回 false。
int getAndSet(int newValue)
- 原子地設置為新值，并返回舊值。底層通常通過循環(huán) CAS 實現(xiàn)。
int getAndIncrement() / int getAndDecrement()
- 原子地遞增/遞減 1，返回舊值。i++ 的原子版本。
int getAndAdd(int delta)
- 原子地加上 delta，返回舊值。
int incrementAndGet() / int decrementAndGet()
- 原子地遞增/遞減 1，返回新值。++i 的原子版本。

3. 代碼示例

示例 1：使用 AtomicInteger 實現(xiàn)線程安全的計數器

import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger atomicInt = new AtomicInteger(0);
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                // 內部通過循環(huán)CAS操作實現(xiàn)原子遞增
                atomicInt.incrementAndGet();
            }
        };
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        // 結果總是 2000，保證了原子性
        System.out.println("Final Count: " + atomicInt.get()); 
    }
}

示例 2：手動使用 compareAndSet 進行自旋

AtomicInteger atomicInt = new AtomicInteger(0);
int oldValue, newValue;
do {
    oldValue = atomicInt.get(); // 獲取當前值作為預期值
    newValue = oldValue + 1;    // 計算新值
} while (!atomicInt.compareAndSet(oldValue, newValue)); 
// 如果CAS失?。╫ldValue已不是當前值），則循環(huán)重試

示例 3：使用 AtomicStampedReference 解決 ABA 問題

import java.util.concurrent.atomic.AtomicStampedReference;
public class ABADemo {
    // 初始值為 100，版本號（Stamp）為 0
    static AtomicStampedReference<Integer> atomicStampedRef = 
            new AtomicStampedReference<>(100, 0);
    public static void main(String[] args) throws InterruptedException {
        int initialStamp = atomicStampedRef.getStamp(); // 獲取初始版本號
        // 線程1模擬ABA操作
        Thread thread1 = new Thread(() -> {
            // 先改成 101，版本號+1
            atomicStampedRef.compareAndSet(100, 101, initialStamp, initialStamp + 1);
            // 再改回 100，版本號再+1
            atomicStampedRef.compareAndSet(101, 100, initialStamp + 1, initialStamp + 2);
        });
        // 線程2嘗試修改
        Thread thread2 = new Thread(() -> {
            // 先睡一會兒，確保線程1完成了ABA操作
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
            // 嘗試修改。雖然期望值還是100，但版本號已經從0變成了2，所以CAS會失?。?
            boolean success = atomicStampedRef.compareAndSet(
                    100, 
                    202, 
                    initialStamp, // 傳入舊的版本號0
                    initialStamp + 1
            );
            System.out.println("CAS successful? " + success); // 輸出：false
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
}

總結

特性	描述
本質	一條CPU原子指令，通過 `Unsafe` 類提供給 Java 開發(fā)者使用。
實現(xiàn)	JDK 的 `java.util.concurrent.atomic` 包下的原子類對其進行了封裝。
核心方法	`compareAndSet(expectedValue, newValue)`
優(yōu)點	無鎖、高性能（低競爭時）、避免死鎖。
缺點	ABA問題（用版本號解決）、自旋CPU開銷（高競爭時）。
應用場景	計數器、序列號生成器、`ConcurrentHashMap` 等高性能并發(fā)容器的實現(xiàn)。