Rust为何仅允许单可变或多不可变借用？单线程下能否防错？

为什么Rust只允许“一个可变借用”或“多个不可变借用”？ #

这是Rust为从根源上保证内存安全设计的核心规则，目标是彻底消灭两类常见的内存bug：

• 读写冲突/逻辑混乱：当同一内存区域被同时读写（或多个写操作并行）时，会产生不可预测的结果——哪怕在单线程里，这种逻辑也会导致程序行为失控（比如遍历集合时修改元素，导致迭代器失效）。
• 悬垂引用：避免借用的内存被释放后，引用还在被使用的情况。

具体来说，可变借用必须独占，是因为如果同时存在可变和不可变引用，或者多个可变引用，就会出现“一边读一边写”或者“多个写操作互相覆盖”的场景。这类场景在其他语言里往往是运行时才暴露的bug，而Rust把它变成了编译错误，提前拦截。

单线程场景下，这种规则能避免易出bug的代码吗？ #

当然可以。很多单线程程序的逻辑bug，本质就是因为未经控制的同时读写操作，Rust的借用规则会在编译阶段就把这类问题拦下来，不用等到运行时出问题才排查。

示例对比： #

1. 多可变引用导致的逻辑混乱（C语言）

在C语言里，你可以同时创建多个指向同一变量的可变指针，这会导致逻辑行为不可控：

#include <stdio.h>

void update_values(int* a, int* b) {
    *a = 5;
    *b = 10;
}

int main() {
    int x = 0;
    // 同时传递两个指向x的可变指针
    update_values(&x, &x);
    printf("x的最终值：%d\n", x); // 输出10，但如果业务逻辑预期是5，就会出现bug
    return 0;
}

这段代码能正常编译运行，但如果开发者误以为x会被设置为5，就会引入难以排查的逻辑错误。

2. Rust的编译期拦截

同样的逻辑在Rust里会直接编译失败：

fn update_values(a: &mut i32, b: &mut i32) {
    *a = 5;
    *b = 10;
}

fn main() {
    let mut x = 0;
    // 尝试创建两个可变引用，编译报错
    update_values(&mut x, &mut x);
    println!("x的最终值：{}", x);
}

编译时会抛出错误：cannot borrow x as mutable more than once at a time，直接阻止了这种可能引发逻辑bug的代码。

3. 遍历集合时修改元素的场景

再比如单线程里遍历集合同时修改元素的常见bug：
在C++里，这段代码会导致未定义行为（可能崩溃、输出乱码）：

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3};
    for (int num : vec) {
        vec.push_back(num); // 遍历期间修改容器，迭代器失效
    }
    return 0;
}

而在Rust里，同样的代码会直接编译报错：

fn main() {
    let mut vec = vec![1, 2, 3];
    for num in &vec {
        vec.push(*num); // 编译报错：cannot borrow `vec` as mutable because it is also borrowed as immutable
    }
}

Rust明确告诉你：当前集合已经被不可变借用（用于遍历），不能同时进行可变借用（修改集合），从根源上避免了迭代器失效的问题。

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