Rust - 在线程之间不安全地共享没有互斥锁的可变数据

Question

如何在 Rust 中实现旧式多线程（无包装互斥量）？ 为什么它是未定义的行为？

我必须构建一个高度并发的物理模拟。 我应该在 C 中完成，但我选择了 Rust（我真的需要更高级别的功能）。

通过使用 Rust，我应该选择线程之间的安全通信，但是，我必须使用线程之间共享的可变缓冲区。 （实际上，我必须实施不同的技术并对它们进行基准测试）

第一种方法

1. 使用Arc<Data>共享不可变的 state。

2. 在需要时使用transmute将&提升为&mut 。

这很简单，但即使使用unsafe块，编译器也会阻止它编译。 这是因为编译器可以应用优化，知道这些数据应该是不可变的（可能被缓存并且从不更新，不是这方面的专家）。

这种优化可以被Cell wrapper 和其他人阻止。

第二种方法

1. 使用Arc<UnsafeCell<Data>> 。

2. 然后data.get()访问数据。

这也不编译。 原因是UnsafeCell不是Send 。 解决方法是使用SyncUnsafeCell ，但目前（1.66）不稳定，程序会在只有稳定版的机器上编译上线。

第三种方法

1. 使用Arc<Mutex<Data>> 。

2. 在每个线程的开头：

   • 锁定互斥量。

   • 通过强制&mut来保留*mut mut 。

   • 释放互斥体。

3. 需要时使用*mut

我还没有尝试过这个，但是即使它编译了，它是否像SyncUnsafeCell一样安全（不是谈论数据竞争）？

PS：并发突变的值只是f32 ，绝对没有 memory 分配或任何同时发生的复杂操作。 最坏的情况，我加扰了一些f32 。

Answer 1

免责声明：可能有很多方法可以解决这个问题，这只是其中一种，基于@Caesar 的想法。

这篇文章的两个要点：

• 您可以使用AtomicU32在线程之间共享f32而不会造成任何性能损失（给定u32已经是原子的架构）
• 您可以使用std::thread::scope来避免Arc的开销。

use std::{
    fmt::Debug,
    ops::Range,
    sync::atomic::{AtomicU32, Ordering},
};

struct AtomicF32(AtomicU32);
impl AtomicF32 {
    pub fn new(val: f32) -> Self {
        Self(AtomicU32::new(val.to_bits()))
    }
    pub fn load(&self, order: Ordering) -> f32 {
        f32::from_bits(self.0.load(order))
    }
    pub fn store(&self, val: f32, order: Ordering) {
        self.0.store(val.to_bits(), order)
    }
}
impl Debug for AtomicF32 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.load(Ordering::Relaxed).fmt(f)
    }
}

fn perform_action(data: &Vec<AtomicF32>, range: Range<usize>) {
    for value_raw in &data[range] {
        let mut value = value_raw.load(Ordering::Relaxed);
        value *= 2.5;
        value_raw.store(value, Ordering::Relaxed);
    }
}

fn main() {
    let data = (1..=10)
        .map(|v| AtomicF32::new(v as f32))
        .collect::<Vec<_>>();

    println!("Before: {:?}", data);

    std::thread::scope(|s| {
        s.spawn(|| perform_action(&data, 0..5));
        s.spawn(|| perform_action(&data, 5..10));
    });

    println!("After: {:?}", data);
}

Before: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
After: [2.5, 5.0, 7.5, 10.0, 12.5, 15.0, 17.5, 20.0, 22.5, 25.0]

---

为了演示这是多么轻量级，这里是编译成的内容：

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

pub struct AtomicF32(AtomicU32);
impl AtomicF32 {
    fn load(&self, order: Ordering) -> f32 {
        f32::from_bits(self.0.load(order))
    }
    fn store(&self, val: f32, order: Ordering) {
        self.0.store(val.to_bits(), order)
    }
}

pub fn perform_action(value_raw: &AtomicF32) {
    let mut value = value_raw.load(Ordering::Relaxed);
    value *= 2.5;
    value_raw.store(value, Ordering::Relaxed);
}

.LCPI0_0:
        .long   0x40200000
example::perform_action:
        movss   xmm0, dword ptr [rdi]
        mulss   xmm0, dword ptr [rip + .LCPI0_0]
        movss   dword ptr [rdi], xmm0
        ret

---

请注意，虽然这包含零个未定义行为，但程序员仍然有责任避免读取-修改-写入竞争条件。