Rust 编程语言在 1.34 之后的版本中开始正式提供完整的原子(Atomic)类型了。所谓的原子是指一系列不可被上下文交换(Context Switch)的机器指令,这些机器指令组成的操作又称为原子操作(Atomic Operation)。在多 CPU 内核的环境下,当某个 CPU 内核开始运行原子操作时,就会先暂停其它 CPU 内核对内存的操作,以保证在原子操作运行的过程中,内存内容不会受到其它 CPU 内核干扰。所以原子操作若用得好,就不需要去使用会拖累程序性能的互斥锁(Mutex)或是消息传递(message passing)机制。只不过依靠原子操作来解决同步问题的话,会牵扯到编译器优化以及 CPU 架构的问题,这篇文章会针对 Rust 编程语言提供的原子类型来探讨原子操作。

先来看看以下这个程序吧!

use std::thread::{self, JoinHandle};

const N_TIMES: u64 = 1000;
const N_THREADS: usize = 10;

static mut R: u64 = 0;

fn reset() {
    unsafe {
        R = 0;
    }
}

fn add_n_times(n: u64) -> JoinHandle<()> {
    thread::spawn(move || {
        for _ in 0..n {
            unsafe {
                R += 1;
            }
        }
    })
}

fn main() {
    loop {
        reset();

        let mut threads = Vec::with_capacity(N_THREADS);

        for _ in 0..N_THREADS {
            threads.push(add_n_times(N_TIMES));
        }

        for thread in threads {
            thread.join().unwrap();
        }

        assert_eq!(N_TIMES * N_THREADS as u64, unsafe { R });
    }
}

全域静态变量 R 是可变的。在 main 函数的无穷循环中,每次迭代会将 R 设为 0,并且创建出 N_THREADS 个线程,每个线程都会运行 N_TIMES 次的 R += 1。也就是说,在理想状态下,我们可以预估无穷循环的每次迭代,R += 1 都会被运行 N_TIMES * N_THREADS 次,所以在该次迭代的最后,R 的值也应为 N_TIMES * N_THREADS 才对。

然而现实并非如此,当 N_THREADS 大于 1 时,R 的值在每次迭代的最后,有可能会小于 N_TIMES * N_THREADS,这就是所谓的竞跑现象(Data Race)。竞跑之所以会发生,是由于 R += 1 这行叙述,虽然它只有一行,但它在实际运行时却可能是由好几个步骤组成,例如:第一步,将 R 读取进 CPU 寄存器;第二步,将该寄存器的值加一;第三步,将该寄存器的值回存给 R。此时若使用超过一个线程来运行 R += 1 这行叙述的话,有可能会变成这样:当第一个线程运行完第二步,还没到第三步时,第二个线程就先运行第一步了,所以会造成第二个线程读取到原本应该已经被第一个线程加一却还没回存好的 R。也有可能会变成这样:当第一个线程运行完第一步后,第二个线程却运行完两轮 R += 1 了,此时第一个线程再继续把第二步和第三步做完反而会让 R 的值比先前的更小!

使用互斥锁可以很轻易地解决这个问题,程序如下:

use std::thread::{self, JoinHandle};
use std::sync::{Mutex, Arc};

const N_TIMES: u64 = 1000;
const N_THREADS: usize = 10;

static mut R: u64 = 0;

fn reset() {
    unsafe {
        R = 0;
    }
}

fn add_n_times(n: u64, mutex: Arc<Mutex<()>>) -> JoinHandle<()> {
    thread::spawn(move || {
        for _ in 0..n {
            let lock = mutex.lock().unwrap();
            // critical section START
            unsafe {
                R += 1;
            }
            // critical section END
            drop(lock);
        }
    })
}

fn main() {
    let mutex = Arc::new(Mutex::new(()));

    loop {
        reset();

        let mut threads = Vec::with_capacity(N_THREADS);

        for _ in 0..N_THREADS {
            threads.push(add_n_times(N_TIMES, mutex.clone()));
        }

        for thread in threads {
            thread.join().unwrap();
        }

        assert_eq!(N_TIMES * N_THREADS as u64, unsafe { R });
    }
}

利用互斥锁形成的临界区段(Critical Section),来使 R += 1 程序叙述在同一时间只能够被一个线程来运行。不过功能强大的互斥锁会需要耗费不少额外的运算资源,在这个例子中,我们其实只需利用 Rust 编程语言的原子类型就能达到相同的结果,性能也会好很多。

程序如下:

use std::thread::{self, JoinHandle};
use std::sync::atomic::{Ordering, AtomicU64};

const N_TIMES: u64 = 1000;
const N_THREADS: usize = 10;

static R: AtomicU64 = AtomicU64::new(0);

fn reset() {
    R.store(0, Ordering::Relaxed);
}

fn add_n_times(n: u64) -> JoinHandle<()> {
    thread::spawn(move || {
        for _ in 0..n {
            R.fetch_add(1, Ordering::Relaxed);
        }
    })
}

fn main() {
    loop {
        reset();

        let mut threads = Vec::with_capacity(N_THREADS);

        for _ in 0..N_THREADS {
            threads.push(add_n_times(N_TIMES));
        }

        for thread in threads {
            thread.join().unwrap();
        }

        assert_eq!(N_TIMES * N_THREADS as u64, R.load(Ordering::Relaxed));
    }
}

以上程序,使用 AtomicU64 来替换原本的 u64,我们甚至还可以把全域静态变量 R 的 mut 关键字拿掉,因为原子类型的值就算不使用 mut 也还是可变的,这点和被 Mutex 类型包裹的值一样。

例如以下程序可以通过编译:

use std::sync::Mutex;
use std::sync::atomic::{Ordering, AtomicU64};

struct Counter {
    count: u64
}

fn main() {
    let n = Mutex::new(Counter {
        count: 0
    });

    n.lock().unwrap().count += 1;

    let n = AtomicU64::new(0);

    n.fetch_add(1, Ordering::Relaxed);
}

在使用原子类型提供的原子操作时,需要额外传入一个 Ordering 枚举的变体实体。这个 Ordering 枚举可不是 std::cmp 这个模块下用来比大小的 Ordering 哦!而是位于 std::sync::atomic 模块下的 Ordering 枚举。

这边的 Ordering 枚举是用来控制原子操作时所使用的「内存顺序」(Memory Ordering)的限制,共有 Relaxed、Acquire、Release、AcqRel、SeqCst 五种变体。

内存顺序

内存顺序是指 CPU 在访问内存时的顺序,这个顺序不单纯是程序叙述的撰写顺序,可能还会因编译器优化,在编译阶段发生改变(reordering),也可能在运行阶段时,因 CPU 的缓存机制而被打乱顺序。

举个例子,在编译以下程序叙述时:

static mut X: u64 = 0;
static mut Y: u64 = 1;

fn main() {
    ...     // A

    unsafe {
        ... // B
        X = 1;
        ... // C
        Y = 3;
        ... // D
        X = 2;
        ... // E
    }
}

如果 C、D 段落根本没有用到 X = 1,那么编译器很可能会直接将 X = 1 和 X = 2 合并在一起,变成:

static mut X: u64 = 0;
static mut Y: u64 = 1;

fn main() {
    ...     // A

    unsafe {
        ... // B
        X = 2;
        ... // C
        Y = 3;
        ... // D
        ... // E
    }
}

此时若段落 A 中有使用新的线程来读取全域静态变量 X,则不可能会读取到当 X 的值为 1 时的结果,因为在编译阶段时就被编译器给省略掉了!

另一方面,假设 X = 1 并没有被编译器省略掉好了,并且在段落 A 中有一个新线程,主线程和段落 A 的线程对于全域变量的运行顺序关系如下:

initial state: X = 0, Y = 1

THREAD Main     THREAD A
X = 1;          if X == 1 {
Y = 3;              Y *= 2;
X = 2;          }

理想的情况下,Y 最终可能的值为:

  • Y = 3:THREAD A 运行完后才运行 THREAD Main。或是 THREAD Main 运行完后才运行 THREAD A。
  • Y = 6:THREAD Main 运行完 Y = 3 后,运行 THREAD A。THREAD A 运行完后,THREAD Main 才继续运行完。

而实际上我们却有可能会得到以下这种状态:

  • Y = 2:THREAD Main 正在运行 Y = 3,THREAD A 此时也开始运行 Y *= 2。3 这个值来不及回存到 Y,Y 就被 Y *= 2 先行取用了(此时取到的 Y 为 1),而当 3 这个值终于回存到 Y 后,Y *= 2 才计算完成,所以 Y 的值变成 2。

上述只是一般的竞跑,更极端一点由 CPU 缓存引起的内存顺序问题还有以下这个:

  • Y = 2:THREAD Main 虽然已经确实运行完 Y = 3 了,但是该 CPU 缓存中的 Y = 3 还没同步到其它 CPU 的缓存中,此时 THREAD A 的 Y *= 2 就开始读取 Y,因此它读到的 Y 值为 1,计算之后就出现 Y = 2 的结果。

甚至即便改成:

initial state: X = 0, Y = 1

THREAD Main     THREAD A
X = 1;          if X == 2 {
Y = 3;              Y *= 2;
X = 2;          }

也还是可能会出现 Y = 2 的情形,因为 X 和 Y 被同步至其它 CPU 的缓存中的顺序不一。

原子操作与内存顺序

Relaxed

Relaxed 只会进行单纯的原子操作,并不会对内存顺序进行任何限制。换句话说,它可以最大幅度地保留编译器优化的程度,不过如果想要在多个原子操作间实现跨线程的同步机制,就得采用其它的内存顺序的限制方式了。

例如以下这个范例:

use std::thread::{self, JoinHandle};

static mut DATA: u64 = 0;
static mut READY: bool = false;

fn reset() {
    unsafe {
        DATA = 0;
        READY = false;
    }
}

fn producer() -> JoinHandle<()> {
    thread::spawn(move || {
        unsafe {
            DATA = 100;                // A
            READY = true;              // B
        }
    })
}

fn consumer() -> JoinHandle<()> {
    thread::spawn(move || {
        unsafe {
            while !READY {}           // C

            assert_eq!(100, DATA);    // D
        }
    })
}

fn main() {
    loop {
        reset();

        let t_producer = producer();
        let t_consumer = consumer();

        t_producer.join().unwrap();
        t_consumer.join().unwrap();
    }
}

单就程序逻辑来看,这样的程序似乎是挺安全的:当 READY 为 true 时,DATA 一定是 100。但是,实际上,这个程序在经过编译器优化或是 CPU 缓存的影响后,可能会让 C 行在读取到 READY 是 true 后,D 行读取到的 DATA 却还是 0。

这东西很反直觉的原因是我们可能比较常在 x86 或是 x86_64 架构上的 CPU 开发程序,而 x86 或是 x86_64 架构的 CPU 属于「强有序」(strongly-ordered)的内存模型,不太会发生内存顺序的问题。但是在如 ARM 架构等使用「弱有序」(weakly-ordered)的内存模型下,内存顺序就很有可能会被打乱。

即便我们将以上程序的 READY,使用原子类型搭配 Relaxed 内存顺序限制来修改,问题也是依旧存在的。

use std::thread::{self, JoinHandle};
use std::sync::atomic::{Ordering, AtomicBool};

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

fn reset() {
    unsafe {
        DATA = 0;
    }
    READY.store(false, Ordering::Relaxed);
}

fn producer() -> JoinHandle<()> {
    thread::spawn(move || {
        unsafe {
            DATA = 100;                                 // A
        }
        READY.store(true, Ordering::Relaxed);           // B
    })
}

fn consumer() -> JoinHandle<()> {
    thread::spawn(move || {
        while !READY.load(Ordering::Relaxed) {}         // C

        assert_eq!(100, unsafe { DATA });               // D
    })
}


fn main() {
    loop {
        reset();

        let t_producer = producer();
        let t_consumer = consumer();

        t_producer.join().unwrap();
        t_consumer.join().unwrap();
    }
}

AcqRel

借由 Acquire 和 Release 这两个内存顺序的限制,可以构筑出一对内存屏障(Memory Barrier),或称内存栅栏(Memory Fence),防止编译器和 CPU 将屏障前(Release)和屏障后(Acquire)中的数据操作重新排在屏障围成的范围之外。

如下:

use std::thread::{self, JoinHandle};
use std::sync::atomic::{Ordering, AtomicBool};

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

fn reset() {
    unsafe {
        DATA = 0;
    }
    READY.store(false, Ordering::Relaxed);
}

fn producer() -> JoinHandle<()> {
    thread::spawn(move || {
        unsafe {
            DATA = 100;                                 // A
        }
        READY.store(true, Ordering::Release);           // B: memory fence ↑
    })
}

fn consumer() -> JoinHandle<()> {
    thread::spawn(move || {
        while !READY.load(Ordering::Acquire) {}         // C: memory fence ↓

        assert_eq!(100, unsafe { DATA });               // D
    })
}


fn main() {
    loop {
        reset();

        let t_producer = producer();
        let t_consumer = consumer();

        t_producer.join().unwrap();
        t_consumer.join().unwrap();
    }
}

原则上,Acquire 用于读取,而 Release 用于写入。但是由于有些原子操作同时拥有读取和写入的功能,此时就需要使用 AcqRel 来设置内存顺序了。在内存屏障中被写入的数据,都可以被其它线程读取到,不会有 CPU 缓存的问题。

SeqCst

SeqCst 就像是 AcqRel 的加强版,用在读取的原子操作时有 Acquire 的效果,用在写入的原子操作时有 Release 的效果,用在同时拥有读取和写入功能的原子操作时则有 AcqRel 的效果。除此之外,它还额外保证所有线程看到的所有 SeqCst 原子操作的先后顺序都是一致的。

另外,Acquire、Release 和 AcqRel 等也可以与 SeqCst 搭配使用,来构筑出一对内存屏障。