先说一个很常见的现场。一个用 C 写的日志聚合服务,跑了三天,进程内存从 200MB 涨到 1.8GB,最后被监控杀掉。重启之后又能撑三天。翻代码,分配和释放看起来是对称的:每个 malloc 后面都有 free。问题出在一条错误分支上——解析失败时提前 return,跳过了释放那一步。这条分支只在某类畸形日志出现时才走到,测试环境从来没造过那种数据。

同样的程序用 Go 写,不会有这个泄漏,GC 会替你收。但另一个问题会冒出来:流量高峰期 GC 停顿,P99 延迟从 20ms 抬到 300ms。你能做的只有调 GOGC、加内存、或者重写热点路径。

Rust 想同时避开这两件事:既不靠 GC 在运行时扫描,也不要求你手工配对分配和释放。它的办法是把「谁负责释放」写进类型系统,让编译器在构建时替你核对。核对不过,编译不通过;核对通过,运行时就没有这层开销。这篇要讲的就是这套机制想解决什么问题、规则是什么、以及你为它付出什么。

本文按 Rust 2021 edition、当前 stable(本机实测为 rustc 1.99)讲解。所有示例都在本机用 cargo run 跑过,编译器的报错文案是从终端直接贴的,只删了路径和无关的警告行。

先看三种内存管理路线

「内存由谁释放」这个问题,主流语言只有三种答法。理解它们的差别,比背 Rust 的规则更重要。

垃圾回收

Java、Go、C#、Python 走这条。运行时定期找出「没人再引用」的对象并回收。写代码省心,不用想释放。代价是运行时要有 GC 线程或标记阶段,内存占用通常更高,停顿时间不可完全预测。对延迟敏感的服,这是一笔要单独算的账。

手动管理

C、C++ 走这条。分配和释放都由人写,运行时零额外成本,控制力最强。代价是前面那个线上问题的来源:每条提前返回、每次异常、每个所有权转移都要人记着。人一定会漏,漏了就是泄漏、重复释放或者悬垂指针。

编译期所有权

Rust 走这条。值的释放点在编译期就确定,离开作用域自动调用 drop。编译器检查引用不会活得比被引用的数据更久,也不允许同一份数据同时被改和被读。没有运行时 GC,也没有手工 free。

三条路线没有绝对优劣,只有把成本放在哪里的区别。GC 把成本放在运行时和内存上,手动管理把成本放在人的注意力上,所有权把成本放在学习和编译时间上。Rust 的选择是:一次性在编译期付清,换来运行时不用再为内存安全提心吊胆。

一次完整的场景走查:从需求到能跑

光讲概念容易飘。用一个最小需求走一遍:读取一组名字,保留第一个名字的副本,再往列表里追加一个新名字,最后打印结果。用 C 写会是这样:

char *first = strdup(names[0]);   // 复制一份
append(&names, "gamma");          // 可能 realloc,旧指针全部失效
printf("%s\n", first);            // 如果 first 指向原来的缓冲区,这里就是悬垂指针
free(first);                      // 还要记得释放

这段代码的坑不在语法,而在「append 可能重新分配底层数组」这个隐含事实。C 的指针不携带任何「这块内存还有效吗」的信息,编译器也无从检查。要让它安全,你得读实现、写注释、靠 code review 兜底。

换成 Rust,需求照写,规则由编译器盯:

fn main() {
    let mut names: Vec<String> = vec![
        String::from("alpha"),
        String::from("beta"),
    ];

    // 取一份独立的副本,类型是 String,拥有自己的堆内存
    let first: String = names[0].clone();

    // 追加会改变长度,但因为 first 是独立副本,不受影响
    names.push(String::from("gamma"));

    println!("first = {first}");
    println!("names = {names:?}");
}

在项目根目录执行 cargo run,输出是:

first = alpha
names = ["alpha", "beta", "gamma"]

注意这里没有 free。三个 String 在 main 结束时各自释放,顺序由编译器插入。也没有 GC,运行时不需要扫描谁还在引用 first。

再看一个不需要复制的情况。函数只是读一下名字,用完就还:

fn describe(name: &str) -> String {
    format!("{name}({} 个字符)", name.chars().count())
}

fn main() {
    let owned = String::from("alpha");
    let line = describe(&owned);   // 借用,不转移所有权
    println!("{line}");
    println!("{owned}");           // 仍然可用
}
alpha(5 个字符)
alpha

&str 里的 & 读作「借用」:我只在函数执行期间看看这块数据,不负责释放,也不许把它带走。describe 返回的 String 是新造的,归调用方所有。这两个约定写进了类型,所以调用方和被调用方都不用猜。

所有权只有三条规则

Rust 的所有权系统,压缩下来就三句话:

每个值有且只有一个所有者所有者是一个变量,或者一个结构体字段。值在所有者离开作用域时被释放。
同一时刻,要么一个可变借用,要么任意多个不可变借用读可以并发,写必须独占。这条规则同时挡住了数据竞争。
借用不能比所有者活得更久引用指向的数据必须先于引用失效,否则就是悬垂指针。生命周期标注就是在描述这层关系。

第一条解释了为什么赋值会让原来的变量「失效」。String 不是几个字节的整数,它在堆上有一块缓冲区。如果把同一个指针同时交给两个变量,两个变量都会在离开作用域时释放它,这就是 double free。Rust 的选择是:赋值即转移(move),原变量不能再读。想在两边都留着,就显式 clone,让代价看得见。

第二条解释了为什么改集合的时候不能持有元素引用。Vec 扩容会把旧缓冲区释放掉,之前的引用立刻变成悬垂指针。C++ 里这叫迭代器失效,标准只说「可能失效」,靠人记;Rust 直接让编译失败。

第三条解释了生命周期标注为什么存在。它不是让变量活得更久,而是告诉编译器「返回的引用来自哪个参数」,好让调用方知道这块数据至少要用到什么时候。

编译器到底在防什么

规则听着抽象,看两条真实报错就具体了。下面这段代码看起来完全合理:把字符串交给另一个变量,然后打印原来的变量。

fn main() {
    let s = String::from("hello");
    let t = s;
    println!("{}", s);
}

rustc 给出的核心信息是(路径已省略):

error[E0382]: borrow of moved value: `s`
  |
2 |     let s = String::from("hello");
  |         - move occurs because `s` has type `String`, which does not implement the `Copy` trait
3 |     let t = s;
  |             - value moved here
4 |     println!("{}", s);
  |                    ^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let t = s.clone();
  |              ++++++++

翻译成人话:String 的堆内存只有一个主人,let t = s 把主人换成了 t,所以 s 已经空了。编译器不是嫌你写得丑,它是在阻止将来某一天 t 和 s 都去释放同一块内存。真需要两份,就 clone;只需要读,就传 &s。

第二种高频报错出现在「边读边改」:

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    v.push(4);
    println!("{}", first);
}
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
  |
3 |     let first = &v[0];
  |                  - immutable borrow occurs here
4 |     v.push(4);
  |     ^^^^^^^^^ mutable borrow occurs here
5 |     println!("{}", first);
  |                    ----- immutable borrow later used here

翻译:first 指向 v 内部的空间,push 可能让 v 换一块缓冲区,first 就成了指向已释放内存的指针。修法很直接:先取值(let first = v[0];,整数是 Copy 的),或者先改完再读,或者确实要保留就 clone。三种改法对应三种真实的成本,编译器把选择权还给你。

现象真实原因第一步查什么
borrow of moved value非 Copy 类型赋值时所有权被转移,原变量已失效看报错里的 value moved here,确认是否该 clone 或改成借用
cannot borrow as mutable because it is also borrowed as immutable持有元素引用期间调用了会改变容量的方法确认引用的最后一次使用位置,把修改挪到引用结束之后
cannot borrow as mutable more than once同时存在两个可变借用用 split_at_mut、下标分段,或改成先处理完一个再借下一个
missing lifetime specifier返回值里的引用无法确定来自哪个参数看函数签名,给输入输出加上同一生命周期,或改成返回拥有所有权的值
does not live long enough被引用的局部变量先于引用被释放找到被借用的变量,让它活得更久,或让函数返回 String
cannot be sent between threads safely类型没有实现 Send,跨线程移动不安全换 Arc<Mutex<T>>,或去掉 Rc 这类单线程共享类型
运行时数据竞争,偶发脏读多线程无同步地读写同一块数据Rust 在编译期就拦住这类代码,若用了 unsafe 则回头查裸指针

「零成本」到底指什么

Rust 常被说成零成本抽象,这句话有严格范围:你写的高层语法,编译后生成的机器码不比手写底层代码多。迭代器的链式调用通常会内联成和 for 循环一样的机器码;Option<&T> 借用优化之后和裸指针一样大;所有权检查全部发生在编译期,运行时不查引用计数,不做标记清扫。

但零成本不等于零开销。编译期要付出:类型检查、借用检查、单态化(为每个具体类型生成一份代码)都会让编译变慢。二进制体积也会因为单态化变大。你可以用 cargo build --release 对比构建时间,这不是玄学,是实打实的代价。

「零成本」只描述运行时。Rust 程序常见的内存错误并不会因为编译通过就消失——逻辑泄漏(忘记清理全局缓存)、无界队列堆积、Box::leak 主动泄漏都仍然存在。所有权管的是「同一块内存被释放几次、被谁释放」,不管「这块内存该不该一直留着」。

边界与代价

第一,学习曲线是真的陡。借用检查器会在你自以为写得很顺的时候连续报错,尤其是想写链表、图、GUI 那种互相引用的数据结构时。这不是编译器有 bug,而是这类结构本来就需要明确的所有权设计。Rc<RefCell<T>>、索引代替指针、Pin 这些方案都有,但每个都有自己的成本和限制。

第二,开发期的迭代速度会变慢。动态语言里改个字段、跑一下看结果,Rust 要先过类型检查和借用检查。项目大时一次全量构建可能要几分钟,这会影响你尝试方案的节奏。热重载、增量编译能缓解一部分,但缓解不了全部。

第三,不是所有场景都值得。一次性脚本、数据清洗、原型验证,Python 或 Go 更快出结果;Rust 的优势在长期维护、性能敏感、内存受限、需要和 C 互操作的地方。拿 Rust 写一个只跑一次的 CSV 转换脚本,收益很难覆盖学习成本。

第四,异步生态的复杂度是另一道坎。async/await 加上所有权,会出现「future 不是 Send」「跨 await 持有锁」这类新问题,排查起来比同步代码费劲。这部分放到进阶篇再讲,入门阶段先把同步代码写顺。

第五,生态比 Java、Go 年轻。常用库都有,但冷门领域可能只有一个半维护的 crate,或者需要自己绑 C 库。选型前先确认你要的能力有没有可靠实现,比学语法更重要。

不要一上来就用 unsafe 绕开借用检查。绕过之后编译器不再替你保证内存安全,段错误、未定义行为都会回来,而且比 C 更难查——因为你以为自己在写安全的 Rust。先把安全子集写熟,再考虑边界。

小结

这篇没有教你任何语法细节,只想让你在写第一行 Rust 之前知道自己在换什么:用编译期的严格检查,换运行时的内存安全和确定的释放时机;用学习曲线和构建时间,换没有 GC 停顿、没有手工 free 的确定性。

后面的报错会一直围绕三条规则出现:值被 move 走了、借用冲突了、引用活得太短了。看到报错先别改代码,先问一句「编译器在防哪个线上问题」,通常就能找到正确的改法。

当天可以自己验证的练习:

  1. 把上面的 let t = s; 改成 let t = s.clone();,确认能编译,并用 cargo run 看输出。
  2. 把 println!("{}", s) 挪到 let t = s; 之前,确认报错消失,理解「最后一次使用」这个概念。
  3. 写一个函数接收 &Vec<String>,在里面遍历打印;再改成接收 Vec<String>,在 main 里调用后继续使用原变量,观察报错。
  4. 用 std::mem::size_of 打印 Option<&i32> 和 &i32 的大小,验证「借用优化」不是空话。
  5. 找一段你写过的 C 或 Go 代码,标出每一处「这块内存什么时候释放」,再想想换成所有权模型会怎么表达。

下一篇讲工具链与 Cargo。所有权规则要落到真实的项目里才有意义,而 Rust 的项目从 cargo new 开始:工具链怎么装、项目目录长什么样、依赖写在哪里、cargo run 背后做了哪些事,这些是动手之前必须先理顺的。