罗罗编程学习记录
本页内容 展开查看

11.3 阶段 2 所有权、借用与生命周期

所属:全栈开发面试题库 / 学习路径 / 11 Rust 全栈

本页目录

一、阶段定位

阶段 1 解决了「怎么写 Rust 代码」,本阶段解决 Rust 真正的门槛——所有权(ownership)、借用(borrowing)与生命周期(lifetime)。这是 Rust 与 C++、Java、Go 在内存管理上的根本分野:Rust 不要求你手动 free(C/C++),也不依赖 GC(Java/Go),而是在编译期用一套规则静态地确定「这块内存归谁、什么时候释放、谁能读、谁能写」。

三条硬规则:

  1. 每一个值在同一时刻只有一个所有者。let s2 = s1; 之后 s1 就失效了,不能再用——这叫 move。
  2. 借用时,同一时刻要么有一个可变借用,要么有任意多个不可变借用,二者互斥。这条规则在编译期杜绝了数据竞争。
  3. 引用的生命周期不能超过它指向的数据的生命周期。函数签名里的 'a 标注就是在告诉编译器「这个引用至少活多久」。

不掌握这三条,后面阶段 3 的 trait 对象、阶段 4 的智能指针、阶段 5 的 async 全部会卡。因为 async 块为什么需要 Pin、Rc<RefCell<T>> 与 Arc<Mutex<T>> 怎么选、为什么 Self 不能在 impl 里返回引用——这些问题的根都是所有权与生命周期。

本阶段与前后阶段的衔接:往上承接阶段 1 的结构体与 String/&str(你会真正理解为什么函数参数用 &str 而不是 String——避免 move);往下交给阶段 3 去解决「怎么用 trait 把这些约束抽象出来」。跳过本阶段直接讲 trait,会让你在 dyn Trait 与泛型的取舍上完全失去判断依据。

「卡点」判断标准:看到下面任一现象,说明本阶段没结束——

  • 看到 error[E0382]: borrow of moved value 时,第一反应是「我把它 clone 一下就好了」,而不是「我应该改成借用」;
  • 写函数返回引用时,必须查教程才能写出 'a,而不是凭直觉知道输入输出位置;
  • 看到 error[E0502]: cannot borrow x as mutable because it is also borrowed as immutable 时,无法定位是哪两个借用在冲突;
  • 不理解 'static 的真实含义,把它等同于「永远在堆上」;
  • 写 async 代码时遇到 future cannot be sent between threads safely 或 Pin 相关错误,完全看不懂。

二、阶段目标与投入

学完本页,应当能用可观察的行为证明以下能力:

能力目标(可验证的行为) 验证方式
能在一段「String 被 move 后又被使用」的代码里,一次定位并修复编译错误 给出 error[E0382] 报错,能在 1 分钟内指出是哪一行 move、哪一行使用
能区分 Copy 与 Clone,说出哪些类型自动实现 Copy、哪些必须显式 derive 写一段 i32 与 String 的赋值对比,解释为什么一个能复制一个会 move
能解释借用规则,并用 NLL 解释为什么 error[E0502] 在某些写法下会消失 写一段「可变借用在使用结束后立即收回」的代码,对比 NLL 前后的差异
能在函数签名里正确加生命周期标注,理解生命周期省略规则的三种情况 写一个返回 &str 的函数,能省略标注;写一个返回两个引用的函数,必须显式标注
能解释 'static 的真实含义,区分「字符串字面量」与「堆分配后还要活很久」 写出 &'static str 与 &'a str 的区别,知道 Box::leak 产生 &'static mut 的代价
能解释为什么自引用结构在 Rust 里困难,以及 Pin 是怎么解决这个问题的(async 块为什么需要 Pin) 写出一个会被 move 的自引用结构,解释 move 后指针指向哪里

建议学时:

  • 全职(每天有效学习 4–6 小时):3 周,约 80–90 小时。这是 Rust 学习曲线最陡的一段,必须逐行动手,不能靠看视频蒙过去。
  • 在职(每天 2 小时、周末补 4 小时):7–8 周,约 90 小时。把每个模块拆成「读 1 小时 + 写 1 小时 + 复盘 0.5 小时」。

学时分配建议:move 与 Copy 15%、借用规则与 NLL 20%、生命周期标注与省略规则 25%、'static 10%、自引用与 Pin 20%、PhantomData 10%。生命周期与 Pin 是面试高频,时间给足。

三、先修自检

进入本阶段前,逐条自检:

先修项 合格标准 不合格时回到
工具链可用 cargo build、cargo test 跑通 11.1 阶段 0 工具链与开发环境
语言基础 能写 enum、match、Option/Result、结构体与 impl 11.2 阶段 1 语言基础与类型系统
String 与 &str 知道函数参数为什么优先 &str 11.2 阶段 1 语言基础与类型系统
指针与堆栈概念 写过 C/C++ 或 Go,理解「栈上值 vs 堆上值」 01 计算机基础与通用工程
编译与运行 知道 debug 与 release 的差别 11.1 阶段 0 工具链与开发环境

经验判断:写过 C++ 的人最容易在「为什么不能 free 一个被函数返回的 &str」上绕,因为 C++ 里你要手动管;写过 Java 的人最容易在「为什么 String 不能随便赋值给两个变量」上绕,因为 GC 允许别名;写过 Go 的人最容易在「为什么 &x 逃逸到堆还要我标生命周期」上绕。这三类偏差都要在练习里主动纠正。

四、知识地图

模块 知识点 掌握程度 对应题库章节
move 与 Copy move 语义、Copy trait、Clone 与 Copy 边界 能讲清原理 04.4.1 所有权与类型系统
借用规则 &T/&mut T、互斥规则、读写锁 能讲清原理 04.4.1 所有权与类型系统
NLL 借用作用域收窄、非词态生命周期 能讲清原理 04.4.1 所有权与类型系统
生命周期标注 'a 在函数签名、结构体、方法中 能讲清原理 04.4.1 所有权与类型系统
生命周期省略规则 输入位置、输出位置、方法 &self 会用 04.4.1 所有权与类型系统
'static 真实含义、字符串字面量、Box::leak 能讲清原理 04.4.1 所有权与类型系统
自引用与 Pin 自引用结构的困难、Pin<P>、pin! 了解 04.4.7 异步运行时与协议层
PhantomData 类型占位、drop check、生命周期标记 了解 04.4.1 所有权与类型系统
常见编译错误 E0382、E0106、E0502、E0515 会用 04.4.1 所有权与类型系统

进度管理建议:把这张表复制到自己的笔记里,每学完一个模块把「掌握程度」往下调一档;三档都到位再进阶段 3。《知识点全清单》是本篇更细的全量清单。

五、分模块精讲

5.1 move 语义与 Copy

为什么需要它:Rust 没有 GC,也不要求手动 free。它用 move 规则在编译期确定「谁是这块内存的最后所有者」。当所有者离开作用域,内存自动释放。这条规则是 Rust 内存安全的根基。

核心机制:

  • 每个值在 Rust 里有且只有一个所有者。
  • 赋值 let s2 = s1;:对于 String 这类非 Copy 类型,默认 move——s1 失效,s2 成为新所有者;之后再用 s1 会报 error[E0382]: borrow of moved value: s1。
  • 函数传参与返回值也是 move:fn takes(s: String) { } 之后,调用方的 s 失效。
  • Copy 类型:在栈上、按位复制就够了的类型(i32、f64、bool、char、不可变引用 &T、只含 Copy 字段的元组/数组)。它们的赋值是「复制」而不是 move,旧变量仍可用。
  • Copy 是 trait:#[derive(Copy, Clone)] 显式标注。一个类型要实现 Copy,它的所有字段都必须 Copy(String 不行,因为它拥有堆数据)。
  • Clone 是「显式深拷贝」:s.clone() 会复制堆数据;它的代价比 Copy 高,必须显式调用。
  • 规则:Copy 是隐式、按位、栈上复制;Clone 是显式、可能深拷贝。优先用 Copy,不要一上来就 clone()。

最小可运行示例:

fn takes_string(s: String) {
    println!("got {s}");
}   // s 在这里 drop,堆内存释放

fn takes_int(n: i32) {
    println!("got {n}");
}

fn main() {
    let s1 = String::from("hello");
    // takes_string(s1);            // move
    // println!("{s1}");             // 编译错误:borrow of moved value

    takes_string(s1.clone());         // 显式深拷贝,s1 仍可用
    println!("s1 still alive: {s1}");

    let n1 = 42;
    takes_int(n1);                    // Copy:n1 仍可用
    println!("n1 still alive: {n1}");
}

常见坑:

现象 原因 修法
error[E0382]: borrow of moved value: s1`` s1 被 move 后又使用 改用借用 &s1,或显式 s1.clone()
函数传参后原变量失效 传的是 String 而不是 &String/&str 函数参数改成 &str,调用传 &s1
到处 .clone() 后性能下降 把 clone 当 GC 的兜底 优先用借用;只在确实需要所有权时 clone
自定义结构体 derive 不了 Copy 有字段不是 Copy(如 String) 去掉 String 字段或改用 &'a str(需要生命周期)

面试考法:高频题是「Copy 与 Clone 的区别,为什么 String 不是 Copy」。答到「Copy 是按位栈复制、隐式、零成本;Clone 是显式深拷贝、可能分配堆内存;String 拥有堆数据,按位复制会让两个 String 指向同一块堆内存,double-free 就会发生,所以不能 Copy」。追问会问「什么类型适合实现 Copy」,答案是「全部字段都是 Copy 的小类型,如 i32、(u8, u8)、自定义 #[derive(Copy)] struct Point { x: i32, y: i32 }」。

5.2 借用规则与 NLL

为什么需要它:move 让所有权清晰,但如果每次都要 move,函数就没法读数据了。借用(&T/&mut T)就是为「只读不拥有」「临时修改不拥有」设计的。它的核心约束是读写互斥——这条规则在编译期杜绝了数据竞争,是 Rust 不需要数据竞争检测器就能保证线程安全的根基。

核心机制:

  • 不可变借用 &T:可以同时存在多个;只读;不能通过它修改数据。
  • 可变借用 &mut T:同一时刻只能有一个;可以读写;它存在期间,其他借用(包括不可变)都不能存在。
  • 规则总结:在同一时刻,要么有任意多个 &T,要么有一个 &mut T,二者不能并存。
  • NLL(Non-Lexical Lifetimes,非词态生命周期):从 Rust 1.31 起,借用的作用域不再是「从声明到块结束」,而是「到最后一次使用为止」。这意味着:
let mut s = String::from("hello");
let r1 = &s;           // 不可变借用 1
let r2 = &s;           // 不可变借用 2
println!("{r1}, {r2}");// 最后一次使用 r1、r2
let r3 = &mut s;       // OK:r1、r2 已结束
println!("{r3}");
  • 在 NLL 之前,这段代码会报错(因为 r1、r2 的词态作用域到块末尾);NLL 后通过。
  • 借用不能「悬垂」:fn dangle() -> &String { let s = String::new(); &s } 会报 error[E0106] 或 error[E0515],因为 s 在函数结束时 drop,返回的引用悬垂。

最小可运行示例:

fn main() {
    let mut data = vec![1, 2, 3];

    // 多个不可变借用共存
    let r1 = &data;
    let r2 = &data;
    println!("{} {}", r1[0], r2[1]);

    // 一个可变借用
    let r3 = &mut data;
    r3.push(4);
    // println!("{r1}");     // 编译错误:r3 还在作用域内,r1 不能再用
    println!("{r3:?}");
}

常见坑:

现象 原因 修法
error[E0502]: cannot borrow data as mutable because it is also borrowed as immutable 不可变借用还在作用域内就拿可变借用 把不可变借用的最后一次使用提前,让 NLL 收窄
error[E0499]: cannot borrow data as mutable more than once at a time 同时拿了两个 &mut 合并成一个可变借用,或分阶段使用
error[E0515]: cannot return reference to local variable s`` 返回了局部变量的引用 返回 s 本身(move),或让调用方传入 buffer
在循环里 &mut data 又 println!("{data:?}") 打印又借用了 data 先打印,再拿可变借用;或先把可变借用的操作做完

面试考法:常问「为什么 Rust 不需要数据竞争检测器」。答到「借用规则在编译期就保证了同一时刻要么多个读要么一个写,数据竞争根本不可能编译通过;这是 Rust 区别于 Go/Java 的根本设计」。追问会问「NLL 是什么,为什么需要它」,答案是「NLL 让借用作用域收窄到最后一次使用而不是块结束,让很多本来要被迫 {} 包裹的代码可以直接写,降低了借用检查的摩擦力」。

5.3 生命周期标注:函数签名、结构体、方法

为什么需要它:当函数返回一个引用时,编译器无法从代码本身判断「这个引用是指向输入参数的,还是指向新创建的局部变量的」。它需要你用生命周期标注 'a 告诉它。这不是为了「延长生命周期」,而是为了说明引用之间的关系——返回的引用至少和输入活得一样长。

核心机制:

  • 生命周期标注的语法:&'a T、&'a mut T。'a 读作「tick a」。
  • 函数签名:
    • 输入位置:每个引用都有自己的生命周期;
    • 输出位置:返回的引用必须与某个输入的生命周期相关联;否则编译器无法保证它不悬垂。
    • 规则:如果函数只有一个输入引用,那么输出引用的生命周期与它相同,编译器可以省略标注。如果有多个输入引用,输出引用必须显式标注是与哪个输入关联。
  • 结构体:如果结构体里持有引用,必须给每个引用加生命周期:struct User<'a> { name: &'a str }。这告诉编译器:User 的实例不能比它引用的 name 活得更久。
  • 方法:impl<'a> User<'a> { fn name(&self) -> &'a str { self.name } }——方法里的 &self 已经带了生命周期,返回 &self.field 时可以省略标注(省略规则见下)。

最小可运行示例:

// 省略规则 1:只有一个输入引用,输出与它同生命周期
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap()
}

// 省略规则 2:两个输入引用,输出必须显式标注与哪个关联
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// 结构体持有引用
struct Excerpt<'a> {
    part: &'a str,
}

impl<'a> Excerpt<'a> {
    // 省略规则 3:方法有 &self,输出与 self 同生命周期
    fn part(&self) -> &str {
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first = novel.split('.').next().unwrap();
    let e = Excerpt { part: first };
    println!("{}", e.part());
    println!("{}", longest("ann", "bob"));
}

常见坑:

现象 原因 修法
error[E0106]: missing lifetime specifier 返回引用没加生命周期标注 给返回引用加 <'a>,如 fn f(x: &str, y: &str) -> &str 改为 fn f<'a>(x: &'a str, y: &'a str) -> &'a str
error[E0106]: missing lifetime specifier 出现在结构体字段 结构体里持有引用但没标注 struct S<'a> { r: &'a str }
返回引用指向了局部变量 函数内 let s = String::new(); &s 返回 s 本身(move),或让调用方传 buffer
结构体实例活得比它引用的数据久 Excerpt { part: &local } 但 local 先 drop 调整作用域顺序,或把 part 改成 String 持有所有权

面试考法:常问「生命周期标注是在延长生命周期吗」。答到「不是,它只是在描述引用之间的关系——返回的引用至少和输入活得一样长;编译器用这个信息检查你不会返回悬垂引用,而不是凭空延长任何东西」。追问会问「什么时候必须显式标注」,答案是「函数有多个输入引用且输出是其中之一;结构体持有引用;泛型约束里要求 T: 'a」。

5.4 生命周期省略规则

为什么需要它:如果每个函数签名都要写 <'a>,代码会非常啰嗦。Rust 设计了三条生命周期省略规则,让编译器能在常见情况下自动推断,你只在它推断不出来时才手写标注。

核心机制:

  • 规则 1(输入位置):编译器给每个输入引用参数自动分配一个独立的生命周期。fn f(x: &str, y: &str) 变成 fn f<'a, 'b>(x: &'a str, y: &'b str)。
  • 规则 2(输出位置):如果只有一个输入生命周期,输出引用的生命周期就是它。fn f(x: &str) -> &str 变成 fn f<'a>(x: &'a str) -> &'a str。
  • 规则 3(方法与 &self):如果方法有 &self 或 &mut self 参数,输出引用的生命周期与 self 相同。这就是为什么 impl 块里写方法时通常不需要标注。
  • 三条规则都用完还不够:编译器会报错,让你手写标注。这就是 error[E0106] 的来源。

最小可运行示例:

// 规则 1 + 规则 2:单输入单输出,可以省略
fn parse(s: &str) -> &str {
    s.trim()
}

// 规则 1 给两个输入各分一个生命周期,但规则 2 不适用(两个输入),规则 3 不适用(不是方法)
// 必须显式标注
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

struct Ctx { name: String }
impl Ctx {
    // 规则 3:输出与 &self 同生命周期,无需标注
    fn name(&self) -> &str {
        &self.name
    }
}

常见坑:

现象 原因 修法
省略标注后报 E0106 多个输入引用,编译器不知道输出关联到哪个 显式 <'a>
方法里返回 &self.x 却报 E0106 方法不是 &self 而是别的形式 检查 fn f(&self, ...) 签名
把 <'a> 到处加导致代码啰嗦 在能省略的地方也加了 先让编译器自动推断,只在报错时加

面试考法:常问「生命周期省略规则有哪三条」。答到「输入每个引用各分一个;单输入时输出与它同生命周期;方法里输出与 self 同生命周期」。追问会问「这三条规则的设计哲学是什么」,答案是「让 95% 的常见函数不需要标注,只在真正有歧义的地方才手写,兼顾安全与可读性」。

5.5 'static 的真实含义

为什么需要它:新手最常误解的生命周期就是 'static。它不是「这个值在堆上活永远」,而是「这个引用在程序整个运行期都有效」。字符串字面量是 &'static str,因为它编译在二进制里;但 Box::leak(...) 也能产生 &'static mut,代价是内存永不释放。

核心机制:

  • 'static 表示引用的有效期是整个程序运行期。
  • 字符串字面量 "hello" 的类型是 &'static str,因为它编译在二进制的只读数据段里,程序退出前都有效。
  • 静态变量 static NAME: &str = "ann"; 的生命周期也是 'static。
  • Box::leak(Box::new(value)) 把一个堆分配的 Box 故意泄漏,返回 &'static mut T;这是「我确实要让它活整个程序」的手动做法,但代价是内存永不释放。
  • T: 'static 这个 trait bound 的含义:「T 不含任何非 'static 的引用」——它不是要求 T 本身是 'static,而是要求 T 里的所有引用都是 'static。例如 String: 'static 成立,&'a str 不成立(除非 'a 是 'static)。
  • 常见误解:&'static T 不意味着 T 在堆上;它只意味着引用本身在程序退出前都有效。

最小可运行示例:

fn take_static(s: &'static str) {
    println!("{s}");
}

fn main() {
    let lit: &'static str = "hello";   // 字面量是 'static
    take_static(lit);

    let owned = String::from("ann");
    // take_static(&owned);              // 编译错误:owned 的生命周期不是 'static

    // Box::leak:手动制造 'static
    let leaked: &'static mut String = Box::leak(Box::new(String::from("leak")));
    println!("{leaked}");
    // 这块内存永远不会释放
}

常见坑:

现象 原因 修法
把 &'a str 参数改成 &'static str 想「延长生命周期」 'static 是上限不是延长手段 改成 &'a str,让调用方决定生命周期
Box::leak 后内存持续上涨 故意泄漏 只在全局单例场景用,配合 OnceLock(阶段 4)
T: 'static 这个 bound 看不懂 误解为要求 T 本身是 'static 它是要求 T 里不含非 'static 引用;String、i32 满足,&'a str 不满足

面试考法:常问「'static 是不是等于「在堆上活永远」」。答到「不是,它只表示引用在整个程序运行期有效;字符串字面量在二进制只读段,不在堆上;堆上的 Box 默认不 'static,要 Box::leak 才会变成 'static,且代价是内存永不释放」。追问会问「T: 'static 的 'static 与 &'static T 的 'static 是同一个意思吗」,答案是「前者是 trait bound,表示 T 里不含非 'static 引用;后者是生命周期标注,表示引用本身活整个程序;两者在语义上相关但用法不同」。

5.6 自引用结构的困难与 Pin

为什么需要它:考虑一个结构,它内部有一个字段指向另一个字段:struct S { s: String, ptr: *const String },ptr 指向 s。问题来了:如果 S 被 move(比如放进 Vec 扩容),s 搬到了新地址,但 ptr 还是旧地址——指向了已无效的位置。这就是「自引用结构」在 Rust 里的根本困难。async 块为什么需要 Pin,就是因为它本质上是一个自引用结构。

核心机制:

  • 自引用结构:字段里的指针指向同结构的另一个字段。
  • move 会让自引用的指针失效:S 在栈上移动时,s 的地址变了,ptr 不更新就悬垂。
  • Pin<P>:是一个包装器,它保证被它包着的指针 P 指向的值永远不会被 move。Pin<Box<T>> 意味着 T 在堆上,且从 Pin 创建之后再也不会被移动。
  • pin! 宏(Rust 1.68+)在栈上把一个值固定住,返回 Pin<&mut T>,适合 async 块。
  • async 块的本质:编译器把 async 块编译成一个状态机,状态机里保存了跨 .await 点的局部变量。如果 .await 之后还要用这些变量,状态机里就会存指向它们的指针——这就是自引用。Pin 保证状态机被 move 时,这些指针不会失效。
  • 大多数 Future 都是 !Unpin 的(含自引用),所以 tokio::spawn 要求 Future: Send + 'static,并且会在内部 Pin 住。

最小可运行示例:

use std::pin::Pin;
use std::marker::PhantomPinned;

// 一个故意自引用的结构:把 PhantomPinned 标记为 !Unpin
#[derive(Debug)]
struct SelfRef {
    value: String,
    ptr: *const String,
    _pin: PhantomPinned,    // 让这个类型 !Unpin
}

impl SelfRef {
    fn new(s: impl Into<String>) -> Pin<Box<Self>> {
        let mut boxed = Box::pin(SelfRef {
            value: s.into(),
            ptr: std::ptr::null(),
            _pin: PhantomPinned,
        });
        // 现在 boxed 已经 Pin 在堆上,value 的地址不会变
        let ptr = &boxed.value as *const String;
        // Safety:boxed 被 Pin 住,value 不会 move
        unsafe { Box::leak(boxed.as_mut()); }
        // 简化示例:真实代码用 Pin::as_mut 配合 unsafe 初始化
        boxed
    }
}

fn main() {
    let s = SelfRef::new("hello".to_string());
    println!("{s:?}");
    // s 被 Pin 在堆上,不会被 move
}

常见坑:

现象 原因 修法
error[E0277]: Future cannot be sent between threads safely 里出现 *const 字段 状态机里含自引用指针,且 *const T 不是 Send 把跨 .await 持有的变量改成 Send 类型,或避免跨 await 持有引用
自引用结构在 Vec 扩容后崩溃 move 让指针悬垂 用 Pin<Box<T>> 把它固定在堆上,或用索引代替指针
把 Pin<&mut T> 直接当 &mut T 用 Pin 解引用有安全要求 用 Pin::get_mut(仅当 T: Unpin)或 unsafe { Pin::into_inner_unchecked }

面试考法:常问「为什么 async 块需要 Pin」。答到「async 块被编译器编译成状态机,跨 .await 的局部变量在状态机里;如果状态机被 move,这些变量的指针就悬垂了;Pin 保证状态机一旦在堆上创建,就不会再被移动,从而让指针始终有效」。追问会问「Unpin 是什么」,答案是「一个标记 trait,说明这个类型可以安全地 move 出 Pin;大多数类型是 Unpin,含自引用的类型(async 状态机、PhantomPinned)不是 Unpin」。

5.7 PhantomData 与返回引用的常见编译错误

为什么需要它:PhantomData<T> 是一个零大小的类型占位符——它不实际存储 T,但告诉编译器「这个类型在逻辑上与 T 有关」。它用于:让编译器知道 drop check 关系、让自定义集合有正确的生命周期标记、在 FFI 里表达「这个指针指向 T」。

核心机制:

  • PhantomData<T>:零大小字段,size_of::<PhantomData<u8>>() == 0。
  • 用途 1:drop check——告诉编译器「这个结构拥有/借用了 T,drop 时要考虑 T 的生命周期」。
  • 用途 2:在自定义迭代器、集合里标记元素类型,让生命周期正确。
  • 用途 3:FFI 里表达「这个 *mut c_void 实际上指向 T」。
  • 常见编译错误:
    • error[E0106]: missing lifetime specifier:返回引用没标注。
    • error[E0515]: cannot return reference to local variable:返回了局部变量的引用。
    • error[E0382]: borrow of moved value:move 后使用。
    • error[E0502]: cannot borrow as mutable because it is also borrowed as immutable:借用冲突。
    • error[E0499]: cannot borrow as mutable more than once at a time:两个 &mut 并存。

最小可运行示例:

use std::marker::PhantomData;

// 一个泛型工厂:不实际存 T,只用来标记类型
struct Factory<T> {
    _marker: PhantomData<T>,
}

impl<T> Factory<T> {
    fn new() -> Self {
        Factory { _marker: PhantomData }
    }
}

fn main() {
    let _f: Factory<String> = Factory::new();
}

常见坑:

现象 原因 修法
error[E0392]: parameter T is never used 泛型参数没在结构体里出现 加 _marker: PhantomData<T>
drop 时编译器没检查 T 的生命周期 没告诉编译器「结构借用了 T」 加 PhantomData<&'a T>
FFI 里 *mut c_void 被当成不指向任何东西 类型信息丢失 用 PhantomData<T> 标记

面试考法:常问「PhantomData 是干什么的」。答到「零大小类型占位,用于告诉编译器泛型参数与本结构的关系,主要用于 drop check、FFI 标记与自定义集合的生命周期标注」。追问会问「为什么不直接存一个 T 字段」,答案是「直接存 T 会让结构变大、需要 T 是具体类型;PhantomData 零大小,只在类型层面有意义,运行时不占空间」。

六、分层练习

6.1 复现型(照着做,目标是「跑通 + 能解释」)

练习 要求 验收标准 预计耗时
move 实验 写一段 String 被 move 后再使用的代码,看 E0382 报错 能指出是哪一行 move、哪一行使用;改成 &str 后通过 1 小时
Copy vs Clone 对比 i32 与 String 的赋值,解释为什么一个能复制一个会 move 能用 std::mem::size_of 证明 PhantomData 是零大小 1 小时
借用冲突 写一段同时 &mut 与 & 的代码,看 E0502/E0499 能在 1 分钟内定位冲突点 1 小时
生命周期标注 写一个 longest<'a>(x, y) -> &'a str 函数 去掉 'a 后看 E0106,再加回来 1 小时
NLL 实验 写一段「不可变借用最后一次使用后立即拿可变借用」的代码 对比 NLL 开启(默认)与手动包 {} 两种写法 1 小时

6.2 改造型(给出现成代码,改出正确行为)

练习 要求 验收标准 预计耗时
消除到处 clone 给定一段满屏 .clone() 的代码,改成借用 性能基准测试中分配次数下降;cargo clippy 不再报 clone_on_copy 2 小时
修复 E0502 给定一段 &mut 与 & 冲突的代码,用 NLL 收窄借用 编译通过,且不需要额外 {} 1.5 小时
返回局部变量的修复 给定 fn f() -> &str { let s = "..."; &s } 改成返回 String(move)或让调用方传 buffer 1 小时
结构体加生命周期 给定 struct S { r: &str },改成 struct S<'a> { r: &'a str } 编译通过;S 的实例不能比 r 活得久 1 小时
自引用结构用 Pin 给定一个会 move 后指针失效的自引用结构,改成 Pin<Box<Self>> 不再悬垂;cargo build 通过 3 小时

6.3 设计型(自己定方案,目标是「能交付、能讲清取舍」)

练习 要求 验收标准 预计耗时
字符串切片工具 实现一个 StrTokenizer,返回 &str 切片而不是 String 函数签名正确使用生命周期;零拷贝 3 小时
借用安全的缓存设计 设计一个「按 key 查并返回 &V」的缓存,要求不能同时写读冲突 用 RwLock(阶段 4 提前接触);返回的引用与锁守卫的关系讲清楚 4 小时
自定义迭代器 实现一个 CharsRev 迭代器,返回 char 正确使用 PhantomData 标记生命周期;实现 Iterator trait 4 小时
Pin 保护的异步任务队列 设计一个任务队列,任务是 Pin<Box<dyn Future<Output = ()> + Send>> 能解释为什么必须 Pin;跨线程安全 4 小时

七、排障表

现象 可能原因 排查步骤 解决办法
error[E0382]: borrow of moved value: s1`` s1 被 move 后又使用 看报错行号;找哪一行把 s1 move 了 改用借用 &s1,或显式 s1.clone()
error[E0106]: missing lifetime specifier 返回引用没加生命周期标注 看函数签名的返回类型 给返回引用加 <'a>
error[E0515]: cannot return reference to local variable s`` 返回了局部变量的引用 看函数内 s 是局部变量 返回 s 本身(move),或让调用方传 buffer
error[E0502]: cannot borrow data as mutable because it is also borrowed as immutable 不可变借用还在作用域内就拿可变借用 找不可变借用的最后一次使用 把最后一次使用提前,让 NLL 收窄
error[E0499]: cannot borrow data as mutable more than once at a time 同时拿了两个 &mut 看两个 &mut 出现的位置 合并成一个可变借用,或分阶段使用
error[E0392]: parameter T is never used 泛型参数没在结构体里出现 看结构体字段 加 _marker: PhantomData<T>
Future cannot be sent between threads safely 含 *const async 状态机里有自引用指针,*const T 不是 Send 看跨 .await 持有的变量类型 把跨 await 的变量改成 Send 类型
自定义结构体实例活得比它引用的数据久 结构体里持有 &'a str 但 'a 对应的变量先 drop 看变量作用域顺序 调整顺序,或把 &'a str 改成 String

八、出口条件

全部勾选后再进入 阶段 3 trait 与抽象设计。

  • [ ] 看到 error[E0382] 能在 1 分钟内定位 move 点与使用点,并选择「借用」或「clone」修复
  • [ ] 能区分 Copy 与 Clone,说出为什么 String 不是 Copy
  • [ ] 能解释借用规则,并能用 NLL 解释为什么某些 E0502 在收窄借用后消失
  • [ ] 能在函数签名里正确加生命周期标注,并说清三条省略规则
  • [ ] 能解释 'static 的真实含义,区分字符串字面量与 Box::leak
  • [ ] 能解释为什么自引用结构在 Rust 里困难,以及 Pin 是怎么解决 async 块的自引用问题
  • [ ] 能说出 PhantomData 的至少两种用途
  • [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径

自测题(先自己想,再看要点):

  1. let s2 = s1; 之后 s1 还能用吗?为什么?let n2 = n1;(n1: i32)呢?
    • 要点:String 是非 Copy 类型,赋值是 move,s1 失效;i32 是 Copy,赋值是按位复制,n1 仍可用。
  2. 为什么 Rust 不需要数据竞争检测器?
    • 要点:借用规则在编译期保证了同一时刻要么多个 &T 要么一个 &mut T,数据竞争根本不可能编译通过。
  3. 生命周期标注是在「延长」生命周期吗?
    • 要点:不是,它只是描述引用之间的关系——返回的引用至少和输入活得一样长;编译器用这个信息检查不会悬垂,而不是凭空延长。
  4. 生命周期省略规则有哪三条?
    • 要点:每个输入引用各分一个;单输入时输出与它同生命周期;方法里输出与 &self 同生命周期。
  5. 'static 是不是等于「在堆上活永远」?
    • 要点:不是,它只表示引用在整个程序运行期有效;字符串字面量在二进制只读段,不在堆上;Box::leak 产生 'static 的代价是内存永不释放。
  6. 为什么 async 块需要 Pin?
    • 要点:async 块被编译成状态机,跨 .await 的局部变量在状态机里;如果状态机被 move,这些变量的指针悬垂;Pin 保证状态机一旦在堆上创建就不会再被移动。
  7. PhantomData<T> 是干什么的?为什么不直接存一个 T 字段?
    • 要点:零大小类型占位,用于 drop check、FFI 标记与生命周期标注;直接存 T 会让结构变大且要求 T 是具体类型,PhantomData 零大小,只在类型层面有意义。