Rust中在Copy类型用std::ptr::write_volatile实现内部可变性的安全性

我想要在Copy值类型中实现内部可变性（用于缓存场景）。目前发现所有支持内部可变性的类型（如UnsafeCell及相关类型、原子类型）都不允许实现Copy trait（稳定版Rust）。

我的问题是：在此场景下，使用std::ptr::write_volatile和std::ptr::read_volatile来实现内部可变性的安全性如何？

具体代码如下：

use std::fmt::{Debug, Display, Formatter};

#[derive(Copy, Clone)]
pub struct CopyCell<T: Copy> {
    value: T,
}

impl<T: Copy> CopyCell<T> {
    pub fn new(value: T) -> Self {
        Self { value }
    }

    pub fn get(&self) -> T {
        unsafe { std::ptr::read_volatile(&self.value) }
    }

    pub fn set(&self, value: T) {
        let ptr = &self.value as *const T;
        let ptr = ptr as *mut T;
        unsafe { std::ptr::write_volatile(ptr, value) }
    }
}

impl<T: Default + Copy> Default for CopyCell<T> {
    fn default() -> Self {
        CopyCell { value: T::default() }
    }
}

impl<T: Display + Copy> Display for CopyCell<T> {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        let value = self.get();
        write!(f, "{value}")
    }
}

impl<T: Debug + Copy> Debug for CopyCell<T> {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        let value = self.get();
        write!(f, "{value:?}")
    }
}

我的目标是在值类型中实现本地缓存（memoization），明确需要Copy语义而非Clone，因为前者在使用场景中更易用。示例用法：

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn simple_test() {
        let a = CopyCell::default();
        let b = CopyCell::new(42);

        assert_eq!(a.get(), 0);
        assert_eq!(b.get(), 42);

        a.set(123);
        b.set(b.get() * 10);
        assert_eq!(a.get(), 123);
        assert_eq!(b.get(), 420);

        let a1 = a;
        let b1 = b;

        a.set(0);
        b.set(0);

        assert_eq!(a1.get(), 123);
        assert_eq!(b1.get(), 420);
    }

    #[test]
    fn cached_compute() {
        let a = CachedCompute::new(10);
        assert_eq!(a.compute(), 100);
        assert_eq!(a.compute(), 100);

        let b = a;
        assert_eq!(b.compute(), 100);
    }

    #[derive(Copy, Clone)]
    pub struct CachedCompute {
        source: i32,
        result: CopyCell<Option<i32>>,
    }

    impl CachedCompute {
        pub fn new(source: i32) -> Self {
            Self {
                source,
                result: Default::default(),
            }
        }

        pub fn compute(&self) -> i32 {
            if let Some(value) = self.result.get() {
                value
            } else {
                let result = self.source * self.source; // assume this is expensive
                self.result.set(Some(result));
                result
            }
        }
    }
}

代码表面运行正常，但想了解是否存在潜在问题或未定义行为，以及未来是否可能引发相关问题。

你的实现存在明确的未定义行为，核心问题在于违反了Rust的内存安全规则，具体原因如下：

1. 违反别名规则（Aliasing Rules） #

Rust的核心内存安全保证之一是：对于同一内存位置，不能同时存在可变引用和不可变引用（或多个可变引用）。你的代码中，set方法通过将&self.value（不可变指针）强制转换为*mut T（可变指针）并写入，同时get方法读取同一位置——这直接违反了别名规则。

read_volatile和write_volatile仅能影响编译器的优化行为（防止编译器重排或省略读写操作），无法绕过Rust的别名限制。即使你用了volatile，编译器仍然可能基于“不可变引用不会被修改”的假设进行优化，导致代码行为异常。

2. 未定义行为的潜在表现 #

当前代码可能在某些平台或编译器版本下“正常运行”，但未定义行为意味着编译器可以任意优化代码，可能导致：

• get方法读取到陈旧的值（编译器认为不可变引用不会被修改，直接缓存了值）
• set方法的写入被编译器完全省略
• 内存访问乱序，导致逻辑错误
• 极端情况下触发内存安全问题（虽然你限制了T: Copy降低了风险，但整体未定义性质不变）

3. Copy语义下的内存拷贝特性 #

因为CopyCell实现了Copy，复制实例时会直接拷贝内部的value字段，原实例和拷贝实例的value指向不同内存位置——这符合你测试中的预期（修改原实例不影响拷贝），但这是Copy语义的必然结果，并非“内部可变性”的问题，只是需要明确这一特性。

替代方案 #

如果你需要在Copy类型中实现本地缓存，且不想引入Clone，可以考虑以下合法方案：

方案1：将缓存逻辑移到外部，使用Copy类型存储缓存状态 #

直接在业务结构体中存储缓存状态，利用Copy语义的拷贝特性：

#[derive(Copy, Clone)]
pub struct CachedCompute {
    source: i32,
    result: Option<i32>,
}

impl CachedCompute {
    pub fn new(source: i32) -> Self {
        Self { source, result: None }
    }

    pub fn compute(&mut self) -> i32 {
        if let Some(value) = self.result {
            value
        } else {
            let result = self.source * self.source;
            self.result = Some(result);
            result
        }
    }
}

这种方式需要compute方法接收&mut self，虽然没有内部可变性，但拷贝后的实例会保留各自的缓存状态，符合你的需求。

方案2：用UnsafeCell手动实现安全封装（需严格遵守约束） #

如果一定要保留内部可变性和Copy，可以用UnsafeCell，但必须手动确保安全：

use std::cell::UnsafeCell;

#[derive(Clone)]
pub struct CopyCell<T: Copy> {
    value: UnsafeCell<T>,
}

// 手动实现Copy：因为UnsafeCell不实现Copy，但T是Copy，拷贝内存安全
unsafe impl<T: Copy> Copy for CopyCell<T> {}

impl<T: Copy> CopyCell<T> {
    pub fn new(value: T) -> Self {
        Self { value: UnsafeCell::new(value) }
    }

    pub fn get(&self) -> T {
        unsafe { *self.value.get() }
    }

    pub fn set(&self, value: T) {
        unsafe { *self.value.get() = value }
    }
}

注意：这种实现必须确保无多线程并发访问（UnsafeCell本身不是线程安全的），且所有访问都通过get/set方法进行。虽然单线程场景下安全，但Rust不会自动检查手动实现的Copy安全性，一旦T的性质改变，可能引入未定义行为。

总结 #

你的原始实现存在未定义行为，不建议使用。如果需要Copy语义的本地缓存，优先考虑方案1；如果必须内部可变性，方案3是相对合法的选择，但需要严格遵循单线程访问的约束。

内容的提问来源于stack exchange，提问作者Ricardo Machado