如何在 Rust 中从不安全内存创建原子

Question

我正在学习不安全的 Rust，并尝试创建一个由指向某些不安全内存的指针支持的原子（例如来自 C 的缓冲区或内存映射文件）。

我试过这个：

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

fn main() -> () {
    let mut v = vec![1i64, 2i64];
    let ptr = &mut v[0] as *mut i64;
    unsafe {
        let a = std::mem::transmute::<*mut i64, AtomicI64>(ptr);
        println!("{}", a.load(Ordering::Relaxed));
    }
}

但它打印的是指针的地址（例如2119547391296）而不是1。

创建位于某些外部缓冲区中的原子的正确方法是什么？

我想要相同的功能，例如 C# Interlocked.CompareExchange(ref *(long*)ptr, ...)，所以也许还有其他方法可以在 Rust 中获取无锁同步原语？

更新：

看起来我需要std::intrinsics::{*}，但它们在稳定的 Rust 中不可用。

更新2：

这会编译并打印1 2 2（即通过指针转换创建然后通过取消引用v[0]按预期更新）。但这是正确的吗？AtomicI64AtomicI64& *ptr

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

fn main() -> () {
    let v = vec![1i64, 2i64];
    let ptr = &v[0] as *const i64 as *const AtomicI64;

    unsafe {
        let a = & *ptr;
        println!("{}", a.load(Ordering::SeqCst));
        a.fetch_add(1i64, Ordering::SeqCst);
        println!("{}", a.load(Ordering::SeqCst));
        println!("{}", v[0]);
    }
}

Answer 1

的文档是AtomicI64这样说的：

此类型与基础整数类型 i64 具有相同的内存表示形式。

但是，您试图将指向 an 的指针i64转换为 an AtomicI64：

unsafe {
  let a = std::mem::transmute::<*mut i64, AtomicI64>(ptr);
  //               is a pointer ^^^^^^^^
  //                                      ^^^^^^^^^ is not a pointer
}

相反，您需要转换*mut i64为对 的指针或引用AtomicI64。

这可以这样实现（安全和不安全的变体）：

// if we have a mut reference, it must have unqiue ownership over the
// referenced data, so we can safely cast that into an immutable reference
// to AtomicI64
fn make_atomic_i64<'a>(src: &'a mut i64) -> &'a AtomicI64 {
  unsafe {
    &*(src as *mut i64 as *const AtomicI64)
  }
}

// if we have a mut pointer, we have no guarantee of ownership or lifetime, and
// therefore it's unsafe to cast into an immutable reference to AtomicI64
unsafe fn make_ptr_atomic_i64<'a>(src: *mut i64) -> &'a AtomicI64 {
  &*(src as *const AtomicI64)
}

例子：

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

fn main() -> () {
    // declare underlying buffer
    let mut v = vec![1i64, 2i64];

    {
        // get atomic safely
        let atomic = make_atomic_i64(&mut v[0]);

        // try to access atomic
        println!("{}", atomic.swap(10, Ordering::Relaxed)); // = 1
    }

    unsafe {
        // get atomic unsafely
        let atomic = make_ptr_atomic_i64(&mut v[0] as *mut i64);

        // try to access atomic
        println!("{}", atomic.swap(100, Ordering::Relaxed)); // = 10
    }

    // print final state of variable
    println!("{}", v[0]); // = 100
}