先说一个很常见的现场。一个用 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 对比构建时间,这不是玄学,是实打实的代价。
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 走了、借用冲突了、引用活得太短了。看到报错先别改代码,先问一句「编译器在防哪个线上问题」,通常就能找到正确的改法。
当天可以自己验证的练习:
- 把上面的
let t = s;改成let t = s.clone();,确认能编译,并用cargo run看输出。 - 把
println!("{}", s)挪到let t = s;之前,确认报错消失,理解「最后一次使用」这个概念。 - 写一个函数接收
&Vec<String>,在里面遍历打印;再改成接收Vec<String>,在main里调用后继续使用原变量,观察报错。 - 用
std::mem::size_of打印Option<&i32>和&i32的大小,验证「借用优化」不是空话。 - 找一段你写过的 C 或 Go 代码,标出每一处「这块内存什么时候释放」,再想想换成所有权模型会怎么表达。
下一篇讲工具链与 Cargo。所有权规则要落到真实的项目里才有意义,而 Rust 的项目从 cargo new 开始:工具链怎么装、项目目录长什么样、依赖写在哪里、cargo run 背后做了哪些事,这些是动手之前必须先理顺的。