Rust中如何存储单所有权数据的可变引用以实现延迟修改？

用Rc<RefCell<Foo>>实现安全的多句柄可变访问 #

既然你不想依赖索引，且需要同一Foo对应多个修改事件，最直接的标准库方案是用Rc<RefCell<Foo>>包装每个Foo实例：

1. 调整存储结构：将原Vec<Foo>改为Vec<Rc<RefCell<Foo>>>，这样每个Foo可以被多个DecayEvent通过Rc持有引用计数的句柄。
2. 定义DecayEvent：让DecayEvent存储Rc<RefCell<Foo>>和调度时间，而非直接的可变引用。
3. 处理事件时获取可变权限：当从BinaryHeap取出事件执行修改时，通过RefCell::borrow_mut()获取Foo的可变引用——由于事件是按时间顺序逐个处理的，同一Foo的修改操作不会并发执行，因此不会触发RefCell的运行时panic。

示例代码：

use std::cell::RefCell;
use std::collections::BinaryHeap;
use std::rc::Rc;
use std::cmp::{Ordering, Reverse};

#[derive(Debug)]
struct Foo {
    value: u32,
}

#[derive(Debug, PartialEq, Eq)]
struct DecayEvent {
    // 用Reverse实现最小堆（BinaryHeap默认是最大堆）
    time: Reverse<u64>,
    target: Rc<RefCell<Foo>>,
}

// 实现Ord让BinaryHeap按时间排序
impl Ord for DecayEvent {
    fn cmp(&self, other: &Self) -> Ordering {
        self.time.cmp(&other.time)
    }
}

impl PartialOrd for DecayEvent {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn main() {
    // 创建包装后的Foo实例
    let foos = vec![
        Rc::new(RefCell::new(Foo { value: 10 })),
        Rc::new(RefCell::new(Foo { value: 20 })),
    ];

    let mut heap = BinaryHeap::new();

    // 为同一个Foo添加多个修改事件
    heap.push(DecayEvent {
        time: Reverse(100),
        target: Rc::clone(&foos[0]),
    });
    heap.push(DecayEvent {
        time: Reverse(200),
        target: Rc::clone(&foos[0]),
    });
    heap.push(DecayEvent {
        time: Reverse(150),
        target: Rc::clone(&foos[1]),
    });

    // 按时间顺序处理事件
    while let Some(event) = heap.pop() {
        let mut foo = event.target.borrow_mut();
        foo.value += 5;
        println!("处理时间{}，Foo值变为{}", event.time.0, foo.value);
    }
}

为什么这个方案可行？ #

• Rc允许同一Foo被多个DecayEvent持有，且不会影响Vec的所有权（Vec仍持有Rc实例，直到main结束）。
• RefCell的运行时检查只会在同时存在多个可变引用时panic，而由于我们按时间顺序逐个处理事件，每次修改时只会存在一个可变引用，完全符合安全规则。
• 无需依赖Vec的索引，所有操作都通过句柄完成。

替代方案：UnsafeCell（需unsafe代码） #

如果追求极致性能且能保证线程安全（单线程场景），可以用UnsafeCell<Foo>配合Rc，但需要手动保证不会同时存在多个可变引用：

use std::cell::UnsafeCell;
use std::collections::BinaryHeap;
use std::rc::Rc;
use std::cmp::{Ordering, Reverse};

#[derive(Debug)]
struct Foo {
    value: u32,
}

#[derive(Debug, PartialEq, Eq)]
struct DecayEvent {
    time: Reverse<u64>,
    target: Rc<UnsafeCell<Foo>>,
}

// 实现Ord让BinaryHeap按时间排序
impl Ord for DecayEvent {
    fn cmp(&self, other: &Self) -> Ordering {
        self.time.cmp(&other.time)
    }
}

impl PartialOrd for DecayEvent {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn main() {
    let foos = vec![
        Rc::new(UnsafeCell::new(Foo { value: 10 })),
        Rc::new(UnsafeCell::new(Foo { value: 20 })),
    ];

    let mut heap = BinaryHeap::new();
    // 添加事件同前...

    while let Some(event) = heap.pop() {
        // 手动保证此时没有其他可变引用
        let foo = unsafe { &mut *event.target.get() };
        foo.value += 5;
        println!("处理时间{}，Foo值变为{}", event.time.0, foo.value);
    }
}

注意：这个方案需要你自己确保不会同时获取多个可变引用，否则会导致未定义行为，仅推荐对Rust内存模型非常熟悉的场景使用。

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