Rust 原子类型详解：无锁并发的利器

Rust 原子类型详解：无锁并发的利器

Rust的所有权系统和借用规则从编译期层面规避了大部分数据竞争，但在多线程共享简单数据时，传统的锁机制虽能保证安全，却会带来上下文切换的性能开销。此时，原子类型（Atomic Types）便成为更高效的选择。它通过硬件层面的原子操作，实现无锁的线程安全，兼顾性能与安全性。

什么是原子类型？

原子类型的核心是原子操作，一种不可被 CPU 上下文切换中断的机器指令，确保多个线程对共享数据的读写操作“不可分割”。简单来说，当一个线程执行原子操作时，其他线程无法看到操作执行过程中的“半成品”状态，要么看到操作前的值，要么看到操作后的值，从根本上避免了数据竞争。

与基本类型相比，原子类型的关键区别的是：它实现了 Sync 特征，可以安全地在多线程间共享，且无需额外的同步机制，比如锁，即可保证操作的原子性；而基本类型若直接跨线程共享，会触发 Rust 的编译期检查报错，即使强行绕过检查，也可能出现未定义行为。

需要注意的是，原子类型并非“万能的线程安全工具”：它仅适用于基本类型（整数、布尔值等），且仅支持有限的原子操作；对于复杂数据结构，仍需结合锁或其他同步机制使用。

Rust中的原子类型

Rust 标准库在 std::sync::atomic 模块中提供了一系列原子类型，覆盖了常用的基础数据类型，每种类型都对应一套原子操作方法。

原子类型

• AtomicBool：原子布尔值，常用于线程间的状态标识。
• AtomicUsize/AtomicIsize：原子无符号/有符号整数，常用于计数器、索引等场景。
• AtomicI8/AtomicU8 ~ AtomicI64/AtomicU64：原子有符号/无符号整数，覆盖不同位宽的需求，需注意部分平台对64位原子类型的支持限制。
• AtomicPtr<T>：原子裸指针，用于原子地操作指针地址，适用于底层无锁数据结构的实现。

原子类型的共享方式

原子类型本身实现了 Sync，但不实现 Send（部分平台除外），因此跨线程共享原子类型时，通常有两种方式：

• 静态变量：将原子类型声明为 static 变量，利用静态变量的全局可见性实现跨线程共享，初始化时需使用常量构造函数。
• 结合 Arc：对于需要动态生命周期的原子类型，可使用 Arc<AtomicXXX>，Arc 保证指针的线程安全共享，原子类型保证内部数据的原子操作。

use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

// 全局静态原子计数器，初始值为0
static COUNTER: AtomicUsize = AtomicUsize::new(0);

fn main() {
    let mut handles = Vec::new();

    // 启动10个线程，每个线程对计数器递增1000次
    for _ in 0..10 {
        let handle = thread::spawn(|| {
            for _ in 0..1000 {
                // 原子递增操作
                COUNTER.fetch_add(1, Ordering::Relaxed);
            }
        });
        handles.push(handle);
    }

    // 等待所有线程执行完成
    for handle in handles {
        handle.join().unwrap();
    }

    // 读取最终计数，预期结果为10*1000=10000
    println!("Final counter value: {}", COUNTER.load(Ordering::SeqCst));
}

核心难点：内存顺序（Memory Ordering）

原子操作的安全性不仅依赖于“不可分割”，还依赖于内存顺序。现代 CPU 为了提升性能，会对指令进行重排（编译器优化、CPU乱序执行），这在单线程中不会影响逻辑，但在多线程中可能导致“数据可见性”问题，比如线程 A 执行的操作，线程 B 可能无法及时看到。

Rust 通过 Ordering 枚举定义了五种内存顺序，用于控制原子操作的重排规则和数据可见性。

常用内存顺序详解

• Relaxed（宽松顺序）：仅保证当前原子操作的原子性，不约束任何指令重排和数据可见性。也就是说，线程 A 的 Relaxed 操作，线程 B 可能延迟看到结果。适用于“无需同步，仅需计数”的场景，如请求计数，性能最优。
• Acquire（获取顺序）：仅用于读操作（如 load），保证后续的所有读写操作不会被重排到当前操作之前，且当前操作能看到其他线程 Release 操作写入的值。
• Release（释放顺序）：仅用于写操作（如 store），保证之前的所有读写操作不会被重排到当前操作之后，且当前操作写入的值能被其他线程的 Acquire 操作看到。
• AcqRel（获取-释放顺序）：结合了 Acquire 和 Release 的特性，适用于“读-改-写”操作（如 fetch_add），保证操作前的读写不重排到操作后，操作后的读写不重排到操作前，且数据可见性同步。
• SeqCst（顺序一致性）：最严格的内存顺序，保证所有线程看到的原子操作顺序完全一致，相当于给所有原子操作加了“全局屏障”。适用于需要全局顺序保证的场景，但性能开销最大。

内存顺序的选择原则

内存顺序的选择核心是平衡性能与安全性，遵循以下原则即可：

• 若仅需原子性，无需同步，如独立计数器：使用 Relaxed。
• 若需线程间同步，如写线程更新数据，读线程读取数据：写操作用 Release，读操作用 Acquire。
• 若需“读-改-写”操作的同步，如计数器递增：使用 AcqRel。
• 若需全局顺序一致，如多线程操作多个原子变量：使用 SeqCst。

use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::thread;
use std::time::Duration;

static READY: AtomicBool = AtomicBool::new(false);
static DATA: AtomicUsize = AtomicUsize::new(0);

fn main() {
    // 写线程：设置数据并标记为就绪
    let writer = thread::spawn(|| {
        DATA.store(42, Ordering::Relaxed); // 先写入数据
        READY.store(true, Ordering::Release); // 标记就绪，保证数据写入在标记之前
    });

    // 读线程：等待就绪后读取数据
    let reader = thread::spawn(|| {
        // 循环等待，直到READY为true（Acquire 保证读取到 true 后，能看到 DATA 的最新值）
        while !READY.load(Ordering::Acquire) {
            thread::sleep(Duration::from_millis(10));
        }
        println!("Data received: {}", DATA.load(Ordering::Relaxed)); // 输出 42
    });

    writer.join().unwrap();
    reader.join().unwrap();
}

原子类型的操作

所有原子类型都提供了一套统一的原子操作方法，核心分为三类：读操作、写操作、读-改-写操作，以下是最常用的操作示例，以 AtomicUsize 为例。

读操作：load

读取原子变量的当前值，需指定内存顺序：

let count = COUNTER.load(Ordering::SeqCst); // 读取计数器当前值

写操作：store

将新值写入原子变量，需指定内存顺序：

COUNTER.store(100, Ordering::Relaxed); // 将计数器设置为100

读-改-写操作

这类操作先读取当前值，再根据当前值修改为新值，全程原子化，是原子类型最常用的操作：

• fetch_add：递增，返回修改前的值。
• fetch_sub：递减，返回修改前的值。
• swap：交换值，返回旧值，可用来实现简单自旋锁。
• compare_exchange：比较并交换（CAS），核心无锁算法基础，若当前值等于预期值，则替换为新值，返回结果。

注意事项与最佳实践

使用原子类型时，若忽略细节，仍可能出现问题，以下是关键注意事项：

• 避免滥用 SeqCst：SeqCst 虽然安全，但性能开销最大，非必要不使用，优先根据场景选择 Relaxed、Acquire/Release。
• 注意平台兼容性：并非所有平台都支持所有位宽的原子类型，如部分嵌入式平台不支持64位原子类型，可通过 cfg(target_has_atomic = "64") 宏做条件编译，保证可移植性。
• CAS 操作需循环重试：compare_exchange 可能因并发冲突失败，需通过循环重试确保操作成功。compare_exchange_weak 允许假失败，性能更优，适合循环场景。
• 原子类型不保证复合操作的原子性：例如“读取值-判断-修改”的复合操作，即使每个步骤都是原子的，整体也不是原子的，需通过 CAS 或锁保证。
• 优先使用静态变量或 Arc 包裹：原子类型本身不适合直接跨线程传递，优先用静态变量（全局共享）或 Arc<AtomicXXX>（动态生命周期）。

总结

Rust的原子类型是无锁并发的核心工具，它通过硬件层面的原子操作，在保证线程安全的同时，避免了锁机制的性能开销。掌握原子类型的用法，能让你在 Rust 并发编程中写出更高效、更安全的代码。