在Rust中不使用引用计数处理循环借用问题

安全阿岳

2026-4-8

嘿，我太懂你现在的困境了——做物理模拟时，Block和Spring互相引用的结构，用普通引用的话Rust编译器直接给你报错，又不想用Rc/Arc那套引用计数来“绕开”问题，想写出更符合Rust原生风格的代码对吧？我来给你几个亲测好用的无引用计数解决方案：

用索引代替直接引用（最推荐的安全方案）
把所有Block和Spring都统一存到一个容器里（比如Vec），然后结构体里不再存对方的引用，而是存它们在容器里的索引（usize类型）。这样完全避开了引用，编译器再也不会跟你纠结借用问题。

举个实际代码例子：

// 用一个Simulation结构体作为所有实体的统一管理者
struct Simulation {
    blocks: Vec<Block>,
    springs: Vec<Spring>,
}

pub struct Block {
    // 存关联弹簧在springs容器中的索引
    spring_indices: Vec<usize>,
    // 物理属性：位置、质量
    position: [f32; 2],
    mass: f32,
}

pub struct Spring {
    // 存关联两个方块在blocks容器中的索引
    a_idx: usize,
    b_idx: usize,
    // 弹簧属性：刚度、原长
    stiffness: f32,
    rest_length: f32,
}

// 实现更新逻辑，通过Simulation统一处理借用
impl Simulation {
    fn update_spring(&mut self, spring_idx: usize) {
        let spring = &self.springs[spring_idx];
        // 这里可以安全地同时获取两个方块的可变引用
        let (block_a, block_b) = self.get_two_blocks_mut(spring.a_idx, spring.b_idx);
        
        // 接下来就可以计算弹簧对两个方块的作用力，更新位置了
        // ... 你的物理计算逻辑
    }

    // 辅助方法：安全获取两个不同方块的可变引用
    fn get_two_blocks_mut(&mut self, idx1: usize, idx2: usize) -> (&mut Block, &mut Block) {
        if idx1 == idx2 {
            panic!("同一个方块不能连在同一个弹簧两端！");
        }
        if idx1 < idx2 {
            let (first, rest) = self.blocks.split_at_mut(idx2);
            (&mut first[idx1], &mut rest[0])
        } else {
            let (first, rest) = self.blocks.split_at_mut(idx1);
            (&mut rest[0], &mut first[idx2])
        }
    }
}

这个方法的好处是完全安全，没有unsafe代码，所有借用都在Rust的规则内。唯一要注意的是管理索引的有效性——比如删除实体时要同步清理相关索引，或者用Option把已删除的实体标记为None，避免访问无效索引。

重新设计数据结构，打破循环依赖
如果你觉得索引管理有点麻烦，也可以试试完全调整结构：让Spring单独持有所有关联关系，Block里不再存任何弹簧的引用。当需要处理某个Block的所有关联弹簧时，直接遍历所有Spring筛选出和它相关的。

比如：

struct Simulation {
    blocks: Vec<Block>,
    springs: Vec<Spring>,
}

pub struct Block {
    position: [f32; 2],
    mass: f32,
}

pub struct Spring {
    a_idx: usize,
    b_idx: usize,
    stiffness: f32,
    rest_length: f32,
}

impl Simulation {
    // 获取某个方块的所有关联弹簧
    fn get_springs_for_block(&self, block_idx: usize) -> Vec<&Spring> {
        self.springs.iter()
            .filter(|s| s.a_idx == block_idx || s.b_idx == block_idx)
            .collect()
    }
}

这种方法适合模拟规模不大的场景，比如只有几十个方块和弹簧，遍历的性能开销完全可以忽略。

实体组件系统（ECS）思路（进阶版）
如果你的模拟规模会越来越大，也可以参考ECS的设计：把Block和Spring的属性拆成独立的组件（比如PositionComponent、MassComponent、SpringComponent），用一个实体ID来关联所有组件，然后用系统来处理不同组件间的交互。不过这个思路其实是索引法的进阶，如果你项目还小，手动用索引就足够了，不用特意引入ECS库。

这些方法都是我在做Rust小项目时踩过坑后总结的，完全不用引用计数，还能完美符合Rust的借用规则，你可以根据自己的项目规模选最适合的。

内容来源于stack exchange