CAS 原理与实战：Go 语言里什么时候该用无锁并发

雨后青山

发布时间：2026-08-25 | 91人浏览过

原创

前言

在 Go 并发代码里，很多人知道 `sync/atomic` 很快，却不一定清楚 CAS 到底解决了什么问题，又会在什么场景下失效。本文从比较并交换的底层逻辑讲起，再结合 Go 的 `atomic` 接口、计数器和自旋锁等实例，帮你判断它适不适合放进自己的性能关键路径。

在 Go 并发代码里，很多人一遇到共享数据就先上 Mutex，这通常没错，但在计数器、状态位这类非常短小的更新路径上，锁并不一定是成本最低的方案。CAS（Compare-And-Swap，比较并交换）正适合这类场景：它依赖硬件原子指令完成更新，不必把 goroutine 挂起再唤醒。

不过，CAS 也不是“比锁更高级”的通用替代品。下面按原理、Go 里的实现方式、几个典型用法以及它的局限性拆开讲，读完你可以更清楚地判断：某段并发逻辑该用原子操作，还是老老实实用互斥锁。

CAS 到底是什么

CAS（Compare-And-Swap）是一种无锁同步算法，用来在不加锁的前提下，让多个线程或协程安全地更新同一份数据。

它有三个核心参数：

内存位置（V）：要读取和更新的目标地址
预期旧值（A）：调用方认为当前应该看到的值
新值（B）：如果比较成功，准备写入的新值

它的规则很直接：只有当内存位置 V 当前的值等于 A 时，才把它改成 B；否则什么也不做，并返回失败。这个比较和写入必须是一个不可分割的原子操作。

用伪代码表示就是：

func CompareAndSwap(addr *T, old, new T) bool {
    if *addr == old {
        *addr = new
        return true
    }
    return false
}

真正的关键不在这段逻辑本身，而在于“比较”和“写回”不能被别的并发操作插进来。也正因为如此，CAS 才能在没有锁的情况下保证数据更新的一致性。

CAS 为什么能做到无锁同步

核心思路：乐观并发控制

CAS 采用的是乐观并发控制思路。它不先假设冲突一定会发生，也不急着加锁，而是先尝试更新：如果发现值已经被别人改过，就说明这次尝试失败，再重试即可。

Go 中 CAS 的典型应用场景示意，包括计数器、自旋锁、无锁结构和状态标志 — **CAS 在 Go 里最常见的四类用法**这一图不展示代码，而是把几种典型用法的适用对象和代价摆在同一页，便于快速比较。

CAS 原理示意图：比较、交换与失败重试的基本过程 — **CAS 的一次更新是怎么完成的**用纸面卡片把 CAS 的比较、写入、失败重试拆开，帮助读者建立“乐观并发控制”的直观模型。

这种方式在冲突不高时很有效，因为省掉了加锁、解锁以及可能的线程阻塞成本。很多高性能并发结构，正是建立在这种“尝试更新，失败重来”的模式上。

底层依赖硬件原子指令

CAS 不是单靠语言层面“约定”出来的，它依赖处理器提供的原子操作能力。常见架构里都有对应支持：

CAS 与 Mutex 的取舍图，强调优势、限制与选型边界 — **什么时候该用 CAS，什么时候该用 Mute**把适用条件和常见风险放在同一张图里，比单纯列优缺点更容易形成选型判断。

x86 架构使用 CMPXCHG 指令
ARM 架构提供 LDREX/STREX 指令对或直接 CAS 指令
RISC-V 架构提供 AMOSWAP 和 LR/SC 指令对

这些指令的意义在于：CPU 能直接在硬件层面完成“读当前值、比较、条件写入”的原子过程，从而避免使用更重的软件同步机制。

Go 里的实现入口

在 Go 语言中，CAS 主要通过 sync/atomic 包暴露出来。常见函数包括：

func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)
func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)
func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)
func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)
func CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool)
func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)

这些接口覆盖了常见的整数和指针类型。底层实现由 Go 运行时和对应架构的汇编代码配合完成。

以 amd64 为例，CompareAndSwapInt32 最终会使用 x86 的 CMPXCHG 指令，并结合 LOCK 前缀保证原子性。LOCK 前缀的作用，是让 CPU 在执行相关指令时对共享内存访问保持原子语义，确保多处理器环境下结果仍然正确。

Go 里怎么用 CAS：几个典型场景

线程安全计数器

计数器是最典型、也最容易理解的 CAS 用法。思路是先读旧值，再计算新值，最后尝试交换；如果交换失败，说明中途被别的 goroutine 改过，重新再来。

type Counter struct {
    value int32
}

func (c *Counter) Increment() {
    for {
        oldValue := atomic.LoadInt32(&c.value)
        newValue := oldValue + 1
        if atomic.CompareAndSwapInt32(&c.value, oldValue, newValue) {
            return
        }
    }
}

func (c *Counter) Value() int32 {
    return atomic.LoadInt32(&c.value)
}

这种写法很适合“单个字段、更新逻辑很短、冲突概率可控”的场景。相较于加锁，它少了锁竞争和 goroutine 切换的成本，因此在高频简单更新中通常更有优势。

自旋锁

CAS 也可以拿来实现自旋锁（SpinLock）。它不是拿不到锁就睡眠，而是不断尝试把标志位从 0 改成 1：

type SpinLock struct {
    flag int32
}

func (sl *SpinLock) Lock() {
    for !atomic.CompareAndSwapInt32(&sl.flag, 0, 1) {
        // 可加入runtime.Gosched()避免过度占用CPU
        runtime.Gosched()
    }
}

func (sl *SpinLock) Unlock() {
    atomic.StoreInt32(&sl.flag, 0)
}

这种做法适用于临界区非常短的情况，比如只执行几个纳秒到微秒级操作。如果临界区稍长，或者竞争很激烈，自旋就会白白烧掉 CPU，得不偿失。

这里的 runtime.Gosched() 是一个很实际的细节：即便采用自旋，也最好适度让出调度机会，避免单纯忙等导致资源占用过高。