MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Rust原子加载与存储操作的实现原理

2021-08-237.1k 阅读

Rust 原子类型基础

在 Rust 中，原子类型位于 std::sync::atomic 模块下。原子类型提供了一种安全的方式来在多线程环境中共享数据，它们通过硬件提供的原子指令来确保操作的原子性。原子类型的基本定义如下：

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

let atomic_var = AtomicUsize::new(0);

这里创建了一个 AtomicUsize 类型的原子变量 atomic_var，初始值为 0。AtomicUsize 是针对无符号整数 usize 的原子类型，类似的还有 AtomicI32、AtomicBool 等。

内存顺序

在理解原子加载与存储操作之前，我们需要先了解内存顺序（Memory Ordering）的概念。内存顺序定义了原子操作与其他内存操作之间的执行顺序关系。Rust 中定义了几种不同的内存顺序，分别为：

  1. Ordering::Relaxed：最宽松的内存顺序，只保证原子操作本身的原子性，不保证与其他内存操作的顺序。例如：
use std::sync::atomic::{AtomicUsize, Ordering};

let atomic_var = AtomicUsize::new(0);
atomic_var.store(1, Ordering::Relaxed);
let value = atomic_var.load(Ordering::Relaxed);

在这个例子中，store 和 load 操作使用 Ordering::Relaxed，它们之间以及与其他内存操作之间的顺序是不确定的。 2. Ordering::Release 和 Ordering::Acquire：Release 顺序保证在该原子操作之前的所有内存操作都对其他线程可见，当其他线程以 Acquire 顺序加载同一个原子变量时。例如：

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

let atomic_var = AtomicUsize::new(0);
let data = 42;

thread::spawn(move || {
    atomic_var.store(1, Ordering::Release);
    // 这里 data 的修改对其他线程可见
});

while atomic_var.load(Ordering::Acquire) != 1 {
    // 等待原子变量更新
}
// 此时 data 的值对当前线程可见
  1. Ordering::SeqCst：顺序一致性（Sequential Consistency），这是最严格的内存顺序。它保证所有线程以相同的顺序观察到所有 SeqCst 原子操作，并且这些操作的顺序与程序顺序一致。例如：
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

let atomic_var1 = AtomicUsize::new(0);
let atomic_var2 = AtomicUsize::new(0);

thread::spawn(move || {
    atomic_var1.store(1, Ordering::SeqCst);
    atomic_var2.store(2, Ordering::SeqCst);
});

while atomic_var1.load(Ordering::SeqCst) != 1 {
    // 等待 atomic_var1 更新
}
while atomic_var2.load(Ordering::SeqCst) != 2 {
    // 等待 atomic_var2 更新
}

在这个例子中，所有线程都会以相同的顺序观察到 atomic_var1 和 atomic_var2 的更新。

原子加载操作

原子加载操作是从原子变量中读取值。在 Rust 中，原子类型提供了 load 方法来实现加载操作。例如：

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

let atomic_var = AtomicUsize::new(10);
let value = atomic_var.load(Ordering::Relaxed);
println!("Loaded value: {}", value);

上述代码中，通过 load 方法从 atomic_var 中读取值，并使用 Ordering::Relaxed 内存顺序。

加载操作的实现原理

从硬件层面来看，原子加载操作通常通过处理器提供的原子读指令来实现。不同的处理器架构可能有不同的原子读指令，例如在 x86 架构上，对于简单的整数类型，普通的读操作本身就是原子的，因为处理器的缓存一致性协议会保证多个处理器核心对内存的访问一致性。但是，对于更复杂的数据类型或者在其他架构（如 ARM）上，可能需要特殊的指令，如 ldrex（Load Exclusive）指令。

在 Rust 中，load 方法的实现依赖于底层操作系统和硬件提供的原子操作支持。Rust 的标准库通过封装这些底层操作，提供了一个统一的接口来进行原子加载。当我们调用 load 方法并指定特定的内存顺序时，Rust 会根据目标平台生成相应的汇编代码，以确保操作满足指定的内存顺序要求。例如，当使用 Ordering::Acquire 时，会生成相应的指令来确保在加载原子变量之前，所有之前的内存操作都已完成并且对当前线程可见。

原子存储操作

原子存储操作是将值写入原子变量。在 Rust 中，原子类型提供了 store 方法来实现存储操作。例如：

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

let atomic_var = AtomicUsize::new(0);
atomic_var.store(42, Ordering::Relaxed);

上述代码中，通过 store 方法将值 42 写入 atomic_var，并使用 Ordering::Relaxed 内存顺序。

存储操作的实现原理

与原子加载操作类似，原子存储操作在硬件层面依赖于处理器提供的原子写指令。在 x86 架构上，普通的写操作对于简单整数类型在单处理器系统中是原子的，但在多处理器系统中，可能需要特殊的指令来保证原子性和内存顺序。例如，x86 架构上的 mfence 指令可以用于保证内存顺序，当使用 Ordering::Release 内存顺序进行原子存储时，可能会生成类似的指令来确保在存储操作之后，之前的所有内存操作对其他线程可见。

在 ARM 架构上，原子存储操作可能会使用 strex（Store Exclusive）指令。Rust 的标准库会根据目标平台选择合适的指令来实现原子存储操作，并根据指定的内存顺序进行相应的内存屏障操作。当我们调用 store 方法并指定 Ordering::Release 时，Rust 会生成代码确保在存储完成后，之前的所有内存操作对其他线程可见，这通常通过插入适当的内存屏障指令来实现。

高级原子操作与加载存储的关系

除了基本的加载和存储操作，Rust 的原子类型还提供了一些高级原子操作，如 fetch_add、fetch_sub 等。这些操作本质上也是基于原子加载和存储操作实现的。

以 fetch_add 为例，其实现过程通常是先原子加载当前值，然后进行加法运算，最后再原子存储新的值。例如：

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

let atomic_var = AtomicUsize::new(10);
let old_value = atomic_var.fetch_add(5, Ordering::Relaxed);
println!("Old value: {}", old_value);
let current_value = atomic_var.load(Ordering::Relaxed);
println!("Current value: {}", current_value);

在这个例子中，fetch_add 操作首先原子加载 atomic_var 的当前值 10，然后加上 5 得到新值 15，再将 15 原子存储回 atomic_var，并返回旧值 10。

这些高级原子操作的实现依赖于原子加载和存储操作的原子性和内存顺序保证。通过组合这些基本操作，Rust 提供了更丰富的原子操作接口，以满足不同的多线程编程需求。

原子加载与存储操作在多线程环境中的应用

在多线程编程中，原子加载和存储操作常用于实现线程间的数据共享和同步。例如，我们可以使用原子变量来实现一个简单的计数器：

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

let counter = AtomicUsize::new(0);
let mut handles = Vec::new();

for _ in 0..10 {
    let counter_clone = counter.clone();
    let handle = thread::spawn(move || {
        for _ in 0..100 {
            counter_clone.fetch_add(1, Ordering::Relaxed);
        }
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

let final_count = counter.load(Ordering::Relaxed);
println!("Final count: {}", final_count);

在这个例子中，10 个线程并发地对 counter 进行 fetch_add 操作，最后通过 load 操作获取最终的计数值。

避免竞态条件

原子加载和存储操作可以有效地避免竞态条件。竞态条件发生在多个线程同时访问和修改共享数据时，导致数据不一致的情况。通过使用原子操作，我们可以确保对共享数据的访问是原子的，从而避免竞态条件。例如，在上述计数器的例子中，如果不使用原子类型，而是使用普通的 usize 类型，多个线程同时对其进行加法操作就会导致竞态条件，最终得到的计数值可能是错误的。

与其他同步原语的结合使用

原子加载和存储操作也可以与其他同步原语（如互斥锁、条件变量）结合使用，以实现更复杂的多线程同步逻辑。例如，我们可以使用互斥锁来保护对原子变量的复杂操作，确保在操作原子变量时不会被其他线程干扰。

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

let atomic_var = Arc::new(AtomicUsize::new(0));
let lock = Arc::new(Mutex::new(()));

let mut handles = Vec::new();
for _ in 0..10 {
    let atomic_var_clone = atomic_var.clone();
    let lock_clone = lock.clone();
    let handle = thread::spawn(move || {
        let _guard = lock_clone.lock().unwrap();
        for _ in 0..100 {
            atomic_var_clone.fetch_add(1, Ordering::Relaxed);
        }
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

let value = atomic_var.load(Ordering::Relaxed);
println!("Final value: {}", value);

在这个例子中，通过互斥锁 lock 保护了对 atomic_var 的 fetch_add 操作，确保在同一时间只有一个线程可以执行该操作。

原子加载与存储操作的性能考量

虽然原子加载和存储操作为多线程编程提供了安全的共享数据访问方式，但它们也会带来一定的性能开销。不同的内存顺序会导致不同的性能表现。

宽松内存顺序的性能

Ordering::Relaxed 是最宽松的内存顺序，它的性能开销相对较小。因为它只保证原子操作本身的原子性，不涉及额外的内存顺序保证，所以在不需要严格内存顺序的场景下，可以使用 Ordering::Relaxed 来提高性能。例如，在一些统计计数器的场景中，只要最终结果正确，对操作顺序没有严格要求，就可以使用 Ordering::Relaxed。

严格内存顺序的性能

Ordering::SeqCst 是最严格的内存顺序，它的性能开销最大。因为它需要保证所有线程以相同的顺序观察到所有 SeqCst 原子操作，这通常需要更多的内存屏障指令来确保内存顺序。在性能敏感的应用中，应尽量避免使用 Ordering::SeqCst，除非确实需要严格的顺序一致性。

Ordering::Release 和 Ordering::Acquire 的性能介于 Ordering::Relaxed 和 Ordering::SeqCst 之间。它们在保证一定内存顺序的同时，性能开销相对 Ordering::SeqCst 较小。在大多数需要线程间同步数据可见性的场景中，Ordering::Release 和 Ordering::Acquire 是比较合适的选择。

跨平台兼容性

Rust 的原子加载和存储操作在不同平台上具有良好的兼容性。Rust 的标准库通过条件编译和对不同平台的适配，确保原子操作在各种主流平台（如 x86、ARM、PowerPC 等）上都能正确工作。

平台特定的优化

虽然 Rust 提供了统一的原子操作接口，但不同平台可能有不同的优化方式。例如，在 x86 架构上，由于其缓存一致性协议和指令集的特点，对于简单整数类型的原子操作可以利用硬件的优势进行优化。而在 ARM 架构上，可能需要更多地依赖特殊的原子指令（如 ldrex 和 strex）来实现原子操作。Rust 的标准库会根据目标平台选择最合适的实现方式，开发者在编写跨平台代码时，通常不需要关心这些底层细节。

处理平台差异

在一些极端情况下，开发者可能需要针对特定平台进行优化。Rust 提供了 cfg 宏来进行条件编译，例如：

#[cfg(target_arch = "x86_64")]
fn platform_specific_optimization() {
    // x86_64 平台特定的优化代码
}

#[cfg(not(target_arch = "x86_64"))]
fn platform_specific_optimization() {
    // 其他平台的默认代码
}

通过这种方式，开发者可以在不同平台上使用不同的实现来优化原子操作的性能。

总结

Rust 的原子加载和存储操作是多线程编程中重要的组成部分。通过理解其实现原理、内存顺序、应用场景和性能考量，开发者可以更有效地使用原子类型来实现线程间的数据共享和同步。同时，Rust 对跨平台兼容性的良好支持，使得开发者可以编写在不同平台上都能正确工作的高效多线程代码。在实际应用中，应根据具体的需求选择合适的内存顺序和原子操作，以平衡性能和正确性。