11.5 阶段 4 智能指针与内部可变性
所属:全栈开发面试题库 / 学习路径 / 11 Rust 全栈
本页目录
一、阶段定位
阶段 2 给了你借用规则,阶段 3 给了你 trait 抽象。但在真实业务里,你会立刻遇到两个问题:
- 递归类型怎么办:
List::Cons(i32, Box<List>)——不用Box包一层,编译器无法确定List的大小。 - 借用规则在某些场景下太严:你需要在「表面上不可变」的结构体内部修改字段,或在多个地方共享同一份数据且需要修改它。这就是内部可变性(interior mutability)。
智能指针(Box/Rc/Arc)与内部可变性类型(Cell/RefCell/Mutex/RwLock)就是解决这两类问题的标准工具。本阶段的核心判断是:
- 单线程共享可变:
Rc<RefCell<T>>——引用计数 + 运行时借用检查。 - 跨线程共享可变:
Arc<Mutex<T>>或Arc<RwLock<T>>——原子引用计数 + 操作系统锁。
选错这两者,要么编译不通过(Rc 不 Send),要么运行时 panic(RefCell 双重借用),要么死锁(Mutex 嵌套)。这是 Rust 面试出现频率最高的组合题。
本阶段与前后阶段的衔接:往上承接阶段 2 的所有权与借用(Box 是唯一拥有者,Rc 是多个拥有者,RefCell 把借用检查从编译期推迟到运行期);往下交给阶段 5 去解决「跨线程并发与异步」——Arc、Mutex、Send/Sync 是并发阶段的入场券。跳过本阶段直接讲并发,会让你在「为什么 Rc 不能跨线程」上完全卡住。
「卡点」判断标准:看到下面任一现象,说明本阶段没结束——
- 看到
Box<List>时,不知道为什么必须用Box包一层; - 写
Rc<RefCell<T>>与Arc<Mutex<T>>时讲不清两者的分工依据; - 运行时遇到
thread panicked at 'already borrowed: BorrowMutError'时,不知道是哪两个borrow_mut冲突; - 死锁复现后,不知道是锁的获取顺序不一致;
- 不知道
Weak是用来打破循环引用的; - 不知道
OnceCell/LazyLock与lazy_static的区别。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下能力:
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能写出 Box<T> 的递归类型(链表、二叉树),解释为什么 Box 是必须的 |
去掉 Box 后看 error[E0072]: recursive type has infinite size |
能解释 Rc<T> 与 Arc<T> 的引用计数开销,以及什么时候选 Arc |
给定「单线程共享只读」与「跨线程共享只读」两种场景,分别选对 |
能写出 Rc<RefCell<T>> 并解释运行时借用检查,复现 borrow_mut 双重借用 panic |
故意写两个 borrow_mut() 看 panic;用 try_borrow_mut 优雅降级 |
能写出 Arc<Mutex<T>> 并解释死锁是怎么发生的,用一致的锁顺序避免 |
复现一个死锁,再用一致顺序修复 |
能解释 Weak 是怎么打破循环引用的(Rc::downgrade + Weak::upgrade) |
画一个父子节点图,展示没有 Weak 时引用计数无法归零 |
能解释 Cow<T> 的用途,以及 OnceCell/LazyLock 的初始化场景 |
给定一个「可能需要修改也可能不需要」的函数参数,选 Cow 而不是 &mut T |
建议学时:
- 全职(每天有效学习 4–6 小时):2 周,约 50–60 小时。
- 在职(每天 2 小时、周末补 4 小时):4–5 周,约 60 小时。
学时分配建议:Box<T> 与递归类型 10%、Rc<T>/Arc<T> 引用计数 15%、Cell<T>/RefCell<T> 内部可变性 20%、Mutex/RwLock 与死锁 20%、Cow<T> 5%、Drop 与析构顺序 5%、Weak 打破循环引用 10%、OnceCell/LazyLock 5%、unsafe 边界 10%。RefCell 与 Mutex 是面试重灾区。
三、先修自检
进入本阶段前,逐条自检:
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 工具链可用 | cargo build、cargo test 跑通 |
11.1 阶段 0 工具链与开发环境 |
| 所有权与借用 | 能解释 move、借用规则、生命周期 | 11.3 阶段 2 所有权、借用与生命周期 |
| trait 基础 | 能写 impl Trait for T、dyn Trait |
11.4 阶段 3 trait 与抽象设计 |
| 错误处理 | 能用 Result、?、thiserror |
11.4 阶段 3 trait 与抽象设计 |
| 线程与锁概念 | 写过 Java/Go,理解 mutex、读写锁、死锁 | 01 计算机基础与通用工程 |
经验判断:写过 C++ 的人最容易在「为什么 shared_ptr 不能跨线程」上对得上(Rust 的 Arc 就是 shared_ptr + 原子操作);写过 Java 的人最容易在「为什么 RefCell 运行时还能 panic」上困惑——Java 的 synchronized 是运行时阻塞,Rust 的 RefCell 是运行时 panic;写过 Go 的人最容易在「为什么 Rc 不能跨线程」上对不上——Go 的指针天然跨线程,Rust 要靠 Arc 显式标记。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
Box<T> |
堆分配、递归类型、独占所有权 | 能讲清原理 | 04.4.1 所有权与类型系统 |
Rc<T>/Arc<T> |
引用计数、Send/Sync、开销 |
能讲清原理 | 04.4.1 所有权与类型系统 |
Cell<T>/RefCell<T> |
内部可变性、运行时借用检查 | 能讲清原理 | 04.4.1 所有权与类型系统 |
Mutex/RwLock |
操作系统锁、死锁、中毒 | 能讲清原理 | 04.4.2 并发与工程实践 |
Cow<T> |
写时复制、借用与拥有的折中 | 会用 | 04.4.1 所有权与类型系统 |
Drop 与析构顺序 |
RAII、drop 顺序、ManuallyDrop |
会用 | 04.4.1 所有权与类型系统 |
Weak<T> |
打破循环引用、downgrade/upgrade |
能讲清原理 | 04.4.1 所有权与类型系统 |
OnceCell/LazyLock |
一次性初始化、惰性初始化 | 会用 | 04.4.1 所有权与类型系统 |
unsafe 边界 |
安全抽象、SAFETY: 注释约定 |
了解 | 04.4.1 所有权与类型系统 |
进度管理建议:把这张表复制到自己的笔记里,每学完一个模块把「掌握程度」往下调一档;三档都到位再进阶段 5。《知识点全清单》是本篇更细的全量清单。
五、分模块精讲
5.1 Box<T> 与递归类型
为什么需要它:Rust 的类型大小必须在编译期确定。递归类型 List::Cons(i32, List) 的大小是无穷的——List 里又有 List,无穷嵌套。编译器需要一层间接,Box<T> 就是这个间接:它是一个堆指针,大小固定(在 64 位平台上 8 字节)。
核心机制:
Box<T>:独占所有权的堆分配智能指针。Box::new(value)在堆上分配,返回一个指向它的指针。Box<T>离开作用域时,自动 drop 堆上的值。Box<T>是Sized的:指针本身大小固定,所以递归类型里用Box<List>就能让List变成Sized。- 典型用途:递归类型(链表、二叉树、AST)、大对象传递避免拷贝、trait 对象(
Box<dyn Trait>)。 - 解引用:
*b拿到内部T;b.field自动通过 Deref 拿到内部字段。
最小可运行示例:
#[derive(Debug)]
enum List {
Cons(i32, Box<List>),
Nil,
}
use List::{Cons, Nil};
fn main() {
let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
println!("{list:?}");
// 大对象避免拷贝
let big = Box::new([0u8; 1024 * 1024]); // 1MB 放堆上
let moved = big; // 只 move 指针,不拷贝 1MB
println!("big len = {}", moved.len());
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0072]: recursive type List has infinite size |
枚举变体直接包含自身 | 在变体里用 Box<List> 包一层 |
| 大对象按值传递导致性能问题 | 函数签名是 [u8; 1MB] 而不是 Box<[u8; 1MB]> |
用 Box 或 &[u8] 传递 |
忘记 Box 离开作用域会 drop 堆数据 |
误以为 Box 是「手动管理」 |
Box 自动 drop,不需要手动 free |
面试考法:常问「为什么 Rust 的递归类型必须用 Box」。答到「Rust 的类型大小必须在编译期确定;递归类型直接包含自身会导致无穷大小;Box 是指针,大小固定,提供了一层间接」。追问会问「Box 与 C++ 的 unique_ptr 有什么区别」,答案是「语义相同——独占所有权、离开作用域自动释放;Rust 没有移动构造函数的复杂语义,Box 的 move 就是指针拷贝」。
5.2 Rc<T> 与 Arc<T>:引用计数与开销
为什么需要它:Box<T> 是独占所有权,但业务里一个数据往往要被多个地方共享(如一棵二叉树的节点被多个子节点引用)。Rc<T>(Reference Counted)是单线程的引用计数智能指针,允许多个所有者共享同一份数据。Arc<T>(Atomic Reference Counted)是跨线程版本,用原子操作维护计数。
核心机制:
Rc::new(value)创建引用计数指针;Rc::clone(&rc)增加计数(不深拷贝);最后一个Rcdrop 时,内部数据 drop。Rc::strong_count(&rc)查看强引用计数;Rc::weak_count(&rc)查看弱引用计数(见 5.7)。Rc<T>是单线程的:它的引用计数用普通非原子操作,不是Send/Sync,不能跨线程。Arc<T>是跨线程的:引用计数用原子操作,是Send/Sync(前提是T: Send + Sync),可以跨线程。- 开销:每次
Rc::clone是一次指针拷贝 + 一次计数加一;每次 drop 是一次计数减一。Arc因为是原子操作,开销略高(但在现代 CPU 上通常可忽略)。 - 规则:单线程共享用
Rc;跨线程共享用Arc。选错会编译不通过(Rc不Send)。
最小可运行示例:
use std::rc::Rc;
fn main() {
let a = Rc::new(String::from("shared"));
println!("strong count = {}", Rc::strong_count(&a)); // 1
let b = Rc::clone(&a);
println!("strong count = {}", Rc::strong_count(&a)); // 2
let c = Rc::clone(&a);
println!("strong count = {}", Rc::strong_count(&a)); // 3
println!("a = {a}, b = {b}, c = {c}");
drop(b);
println!("after drop b, count = {}", Rc::strong_count(&a)); // 2
}
// 跨线程版本:Arc
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3]);
let mut handles = vec![];
for _ in 0..3 {
let d = Arc::clone(&data);
handles.push(thread::spawn(move || {
println!("len = {}", d.len());
}));
}
for h in handles { h.join().unwrap(); }
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0277]: Rc<String cannot be sent between threads safely |
把 Rc 跨线程传 |
改用 Arc |
| 循环引用导致内存泄漏 | 两个 Rc 互相引用,计数永远不归零 |
用 Weak 打破(见 5.7) |
Rc::clone 被误用成深拷贝 |
误以为 clone 会复制内部数据 | Rc::clone 只增加计数;要深拷贝用 (*rc).clone() |
面试考法:常问「Rc 与 Arc 的区别,什么时候选哪个」。答到「Rc 是单线程引用计数,用非原子操作,不能跨线程;Arc 是跨线程版本,用原子操作;单线程共享用 Rc(开销小),跨线程共享用 Arc」。追问会问「Rc::clone 为什么不深拷贝」,答案是「引用计数的本质就是共享同一份数据,clone 只增加计数;深拷贝是 (*rc).clone()」。
5.3 Cell<T> 与 RefCell<T>:运行时借用检查
为什么需要它:借用规则在编译期把「同一时刻要么多个读要么一个写」执行死了。但有些场景下,你需要在「表面上不可变」的结构体内部修改字段——例如缓存的 lazy 初始化、观察者模式里的订阅列表。这就是内部可变性:Cell<T> 与 RefCell<T> 把借用检查从编译期推迟到运行期。
核心机制:
Cell<T>:用于Copy类型(如i32)。cell.get()返回T的副本;cell.set(v)直接替换。没有借用检查,因为它只操作Copy值。RefCell<T>:用于非Copy类型。它在内部维护一个借用计数:borrow()拿不可变借用,返回Ref<T>;borrow_mut()拿可变借用,返回RefMut<T>;- 运行时检查:同一时刻只能有一个
borrow_mut,或多个borrow,二者互斥; - 违反规则时 panic:
thread panicked at 'already borrowed: BorrowMutError'。
- 规则:
RefCell把借用检查从编译期移到运行期——编译通过了,但运行时可能 panic。这是「用运行时风险换编译时灵活性」。 try_borrow()/try_borrow_mut():返回Result,不 panic,用于优雅降级。
最小可运行示例:
use std::cell::RefCell;
struct User {
name: String,
age: RefCell<u32>, // 内部可变性
}
fn main() {
let u = User {
name: String::from("ann"),
age: RefCell::new(28),
};
// 表面上不可变,内部却能改
*u.age.borrow_mut() += 1;
println!("age = {}", u.age.borrow());
// 故意触发 panic:同时两个 borrow_mut
let r1 = u.age.borrow_mut();
// let r2 = u.age.borrow_mut(); // 取消注释即 panic: already borrowed
drop(r1);
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
thread panicked at 'already borrowed: BorrowMutError' |
同时两个 borrow_mut |
用 try_borrow_mut() 优雅降级;或重构借用作用域 |
thread panicked at 'already mutably borrowed: BorrowError' |
borrow_mut 还在作用域内又 borrow |
让 borrow_mut 的作用域提前结束 |
RefCell<&'a str> 报生命周期错误 |
RefCell 内部持有引用 |
改为 RefCell<String> 或正确标注生命周期 |
面试考法:常问「Cell 与 RefCell 的区别,为什么需要内部可变性」。答到「Cell 用于 Copy 类型,get/set 直接操作;RefCell 用于非 Copy 类型,运行时借用检查,违反规则 panic;内部可变性让你在不可变引用的方法里修改字段(如缓存 lazy 初始化)」。追问会问「RefCell 与 Mutex 的区别」,答案是「RefCell 是单线程运行时借用检查,冲突时 panic;Mutex 是跨线程操作系统锁,冲突时阻塞,中毒时返回 Err」。
5.4 Mutex<T> 与 RwLock<T>:死锁与中毒
为什么需要它:RefCell 是单线程的。跨线程共享可变数据时,你需要操作系统级别的锁。Mutex<T> 是互斥锁,同一时刻只允许一个线程访问;RwLock<T> 是读写锁,允许多个读或一个写。
核心机制:
Mutex::new(value)创建锁;mutex.lock()返回LockResult<MutexGuard<T>>,guard 离开作用域时自动解锁(RAII)。RwLock::new(value);.read()拿读锁(多个),.write()拿写锁(一个)。- 中毒(poisoning):如果一个线程在持有锁时 panic,锁会被标记为「中毒」;后续
lock()会返回Err,里面是中毒的 guard。这是为了防止「数据处于不一致状态时仍被其他线程读取」。 - 死锁:两个线程以不同顺序获取两把锁——线程 A 拿锁 1 等锁 2,线程 B 拿锁 2 等锁 1,互相等待。
- 避免死锁的规则:所有线程以相同顺序获取多把锁。
Mutex<T>是Send + Sync(前提是T: Send);RwLock<T>同理。
最小可运行示例:
use std::sync::Mutex;
use std::thread;
fn main() {
let counter = Mutex::new(0);
let mut handles = vec![];
for _ in 0..10 {
let c = &counter;
handles.push(thread::spawn(move || {
let mut n = c.lock().unwrap(); // 拿锁
*n += 1;
})); // n 离开作用域,自动解锁
}
for h in handles { h.join().unwrap(); }
println!("counter = {}", *counter.lock().unwrap()); // 10
}
// 死锁复现
use std::sync::{Mutex, LazyLock};
use std::thread;
static LOCK1: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
static LOCK2: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
fn main() {
let h1 = thread::spawn(|| {
let _a = LOCK1.lock().unwrap();
let _b = LOCK2.lock().unwrap(); // 先 1 后 2
});
let h2 = thread::spawn(|| {
let _b = LOCK2.lock().unwrap();
let _a = LOCK1.lock().unwrap(); // 先 2 后 1——死锁
});
h1.join().unwrap();
h2.join().unwrap();
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 程序卡死不动 | 死锁 | 用 std::thread::sleep 复现;统一锁获取顺序 |
PoisonError |
持锁线程 panic,锁中毒 | .lock().unwrap_or_else(|e| e.into_inner()) 强制拿中毒 guard |
| 持锁时间过长导致性能下降 | 锁内做了 IO 或计算 | 锁内只做数据修改,锁外做 IO |
忘记 MutexGuard 离开作用域自动解锁 |
误以为要手动 unlock |
用 RAII,guard 离开作用域自动解锁 |
面试考法:常问「Mutex 与 RefCell 的区别,什么时候选哪个」。答到「RefCell 是单线程运行时借用检查,冲突 panic;Mutex 是跨线程操作系统锁,冲突阻塞,中毒返回 Err」。追问会问「死锁怎么避免」,答案是「所有线程以相同顺序获取多把锁;避免持锁时再调用未知代码;用 try_lock 加超时降级」。再追问会问「Mutex 中毒是什么意思」,答案是「持锁线程 panic 后数据可能不一致,锁被标记为中毒,后续 lock 返回 Err;这是为了防止不一致数据被其他线程读取」。
5.5 Cow<T> 与写时复制
为什么需要它:业务里经常有「函数参数大多数时候只读,但少数时候需要修改」的场景。用 &T 则无法修改;用 &mut T 则强制调用方必须有可变权限,即使不需要修改;用 T 则每次都深拷贝。Cow<T>(Clone on Write)是这三者的折中:默认借用,需要修改时才克隆。
核心机制:
Cow<'a, B>:是一个枚举,要么Borrowed(&'a B),要么Owned(B::Owned)。Cow::from(&str)创建借用版本;Cow::from(String::from(...))创建拥有版本。to_mut():如果当前是Borrowed,克隆成Owned再返回可变引用;如果已经是Owned,直接返回可变引用。- 典型场景:函数参数大多数调用方传
&str(借用),少数需要修改时to_mut()克隆。
最小可运行示例:
use std::borrow::Cow;
fn normalize(input: Cow<str>) -> Cow<str> {
let trimmed = input.trim();
if trimmed.chars().all(|c| c.is_ascii_lowercase()) {
Cow::Borrowed(trimmed) // 不需要修改,零拷贝
} else {
Cow::Owned(trimmed.to_lowercase()) // 需要修改,克隆
}
}
fn main() {
let s = " Hello World ";
let r = normalize(Cow::from(s));
println!("{r}"); // "hello world"
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
to_mut() 后性能下降 |
每次都触发克隆 | 只在确实需要修改时调用 to_mut() |
Cow<str> 与 String 混用 |
类型不匹配 | Cow::into_owned() 转成 String,或 Cow::as_ref() 转成 &str |
面试考法:常问「Cow 解决了什么问题」。答到「默认借用零拷贝,需要修改时才克隆;避免了『要么强制可变参数、要么每次深拷贝』的二选一」。追问会问「Cow 与 &str/String 的关系」,答案是「Cow<'a, str> 可以从 &'a str 或 String 创建;它实现了 Deref,所以 &*cow 可以当 &str 用」。
5.6 Drop 与析构顺序
为什么需要它:Rust 没有 GC,也没有手动 free。Drop trait 是「离开作用域时自动执行清理」的机制,相当于 C++ 的析构函数。理解 Drop 的触发时机与顺序,你才能正确管理文件句柄、锁、网络连接。
核心机制:
trait Drop { fn drop(&mut self); }:实现后,值离开作用域时自动调用。- drop 顺序:局部变量按声明顺序的逆序 drop(LIFO)。
- 结构体字段按声明顺序 drop;枚举按当前变体的字段顺序。
drop(x)函数显式提前 drop。ManuallyDrop<T>:把一个值标记为「不自动 drop」,用于 FFI 或特殊场景;需要手动ManuallyDrop::into_inner()取出并 drop。Box::leak:把Box<T>泄漏成&'static mut T,永不 drop(见阶段 2)。
最小可运行示例:
struct Resource { name: &'static str }
impl Drop for Resource {
fn drop(&mut self) {
println!("dropping {}", self.name);
}
}
fn main() {
let _a = Resource { name: "a" };
let _b = Resource { name: "b" };
let _c = Resource { name: "c" };
println!("main body end");
// 离开作用域时按 c, b, a 顺序 drop
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 文件句柄泄漏 | File 没离开作用域就被遗忘 |
用 {} 缩小作用域,或显式 drop(f) |
Drop 里又 panic |
析构函数 panic 会导致 abort | Drop 里不要 panic,用 catch_unwind 或日志 |
| 顺序不对导致资源使用异常 | 依赖 drop 顺序做业务逻辑 | 显式 drop() 而不是依赖作用域 |
面试考法:常问「Rust 的析构顺序是什么」。答到「局部变量按声明逆序(LIFO);结构体字段按声明顺序;drop(x) 显式提前释放」。追问会问「Drop 里能不能 panic」,答案是「能,但会导致整个线程 abort,所以 Drop 里不要 panic,错误应当通过返回值或日志表达」。
5.7 Weak<T>:打破循环引用
为什么需要它:Rc/Arc 的引用计数在「两个 Rc 互相引用」时永远不归零,导致内存泄漏。典型场景:二叉树的父节点指向子节点(强引用),子节点指回父节点(如果也是强引用,就泄漏)。Weak<T> 是不增加强引用计数的「弱引用」,用来打破循环。
核心机制:
Rc::downgrade(&rc)创建Weak<T>,只增加弱引用计数,不影响强引用归零。Weak::upgrade(&self) -> Option<Rc<T>>:尝试把弱引用升级成强引用;如果强计数已经归零,返回None。- 规则:数据结构里的「父子」关系用
Rc(强引用),「反向引用」(子到父)用Weak(弱引用)。 - 这样父节点 drop 时,强计数归零,子节点也 drop;子节点的
Weak不再能upgrade成功。
最小可运行示例:
use std::rc::Rc;
use std::cell::RefCell;
#[derive(Debug)]
struct Node {
name: String,
children: RefCell<Vec<Rc<Node>>>,
parent: RefCell<Weak<Node>>, // 弱引用,打破循环
}
fn main() {
let leaf = Rc::new(Node {
name: "leaf".to_string(),
children: RefCell::new(vec![]),
parent: RefCell::new(Weak::new()),
});
let branch = Rc::new(Node {
name: "branch".to_string(),
children: RefCell::new(vec![Rc::clone(&leaf)]),
parent: RefCell::new(Weak::new()),
});
*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
println!("branch strong = {}, weak = {}",
Rc::strong_count(&branch),
Rc::weak_count(&branch)); // strong=1, weak=1
println!("leaf strong = {}, weak = {}",
Rc::strong_count(&leaf),
Rc::weak_count(&leaf)); // strong=2, weak=0
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
内存泄漏,Drop 不被调用 |
两个 Rc 互相强引用 |
反向引用改用 Weak |
Weak::upgrade() 返回 None |
强计数已归零 | 业务上处理 None,表示父节点已释放 |
面试考法:常问「Rc 怎么导致内存泄漏,Weak 怎么解决」。答到「两个 Rc 互相强引用,计数永远不归零;Weak 不增加强计数,父节点 drop 时子节点也 drop,Weak::upgrade 返回 None」。追问会问「树结构里父指针用 Rc 还是 Weak」,答案是「子到父用 Weak,父到子用 Rc——因为父节点拥有子节点,子节点不拥有父节点」。
5.8 OnceCell/LazyLock 与 unsafe 边界
为什么需要它:全局单例、lazy 初始化是常见需求。以前 Rust 用 lazy_static! 宏或 unsafe 的 static mut。Rust 1.70 起标准库提供 OnceCell(单线程)与 LazyLock(跨线程),无需 unsafe。
核心机制:
OnceCell<T>:单线程的一次性初始化容器。OnceCell::new()创建空 cell;cell.set(value)一次性填充;后续get()返回&T。LazyLock<T, F>:跨线程的惰性初始化容器。LazyLock::new(|| { ... })创建,第一次.get()时调用闭包初始化,之后返回缓存的&T。- 对比:
OnceCell需要你显式set;LazyLock第一次get时自动调用闭包。 LazyLock内部用Mutex保证多线程下只初始化一次。unsafe边界:Rust 的安全抽象(Box、Rc、Arc、Mutex)内部用unsafe实现,但对外暴露安全 API。写unsafe代码时,必须用SAFETY:注释约定说明「我在这里遵守了哪些安全前提」。
最小可运行示例:
use std::sync::LazyLock;
use std::collections::HashMap;
static CONFIG: LazyLock<HashMap<String, String>> = LazyLock::new(|| {
let mut m = HashMap::new();
m.insert("host".to_string(), "localhost".to_string());
m.insert("port".to_string(), "8080".to_string());
m
});
fn main() {
println!("host = {}", CONFIG.get("host").unwrap());
}
// 自定义安全抽象的 SAFETY 注释约定
/// # Safety
/// `ptr` 必须是指向一个有效 `i32` 的非空指针,且调用期间不被其他线程修改。
unsafe fn read_i32(ptr: *const i32) -> i32 {
// SAFETY:调用方保证 ptr 有效且独占
unsafe { *ptr }
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
用 static mut 做全局变量报 unsafe |
全局可变静态是未定义行为温床 | 改用 LazyLock 或 Mutex |
OnceCell::set 报「already initialized」 |
重复 set | 用 get_or_init 或只 set 一次 |
unsafe 代码没有 SAFETY: 注释 |
违反安全抽象约定 | 在 unsafe 块前写 // SAFETY: ...,说明遵守了哪些前提 |
面试考法:常问「LazyLock 与 lazy_static! 的区别」。答到「LazyLock 是标准库,跨线程安全,不需要额外依赖;lazy_static 是第三方宏,本质上是 OnceLock 的封装」。追问会问「为什么 Rust 不鼓励 unsafe」,答案是「unsafe 是负债——编译器不再检查你遵守了哪些约定;能用安全抽象(Arc、Mutex、LazyLock)解决的场景不要手写裸指针;确实需要时要用 SAFETY: 注释文档化前提」。
六、分层练习
6.1 复现型(照着做,目标是「跑通 + 能解释」)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
Box 递归类型 |
写一个链表 List::Cons(i32, Box<List>) |
去掉 Box 后看 E0072 |
1 小时 |
Rc 引用计数 |
写三个 Rc::clone 并打印 strong_count |
能解释每次 clone 与 drop 后的计数变化 | 1 小时 |
RefCell panic |
故意两个 borrow_mut() 看 panic |
用 try_borrow_mut 优雅降级 |
1 小时 |
Mutex 计数器 |
用 Arc<Mutex<usize>> 让 10 个线程并发加 1 |
最终结果是 10;不加锁会得到随机值 | 1.5 小时 |
Weak 打破循环 |
写父子节点结构,子节点用 Weak<Node> |
强计数能归零;Drop 被调用 |
2 小时 |
6.2 改造型(给出现成代码,改出正确行为)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
把 Rc 改成 Arc |
给定一段单线程 Rc 代码,改成跨线程版本 |
std::thread::spawn 能传 |
1 小时 |
修复 RefCell panic |
给定一段 borrow_mut 冲突代码,用 try_borrow_mut 降级 |
不再 panic;冲突时返回默认值 | 1.5 小时 |
| 修复死锁 | 给定一段锁顺序不一致的死锁代码,统一顺序 | 程序不再卡死;join 成功 |
2 小时 |
用 Cow 替代 &mut T |
给定一个「大多数时候只读、少数时候改」的函数,改成 Cow |
调用方不需要传 &mut;需要修改时才克隆 |
1.5 小时 |
用 LazyLock 替代 static mut |
给定一段 unsafe static mut 全局变量,改成 LazyLock |
不再需要 unsafe |
1 小时 |
6.3 设计型(自己定方案,目标是「能交付、能讲清取舍」)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 线程安全的缓存 | 设计一个 HashMap<String, Vec<u8>> 缓存,跨线程读写 |
用 Arc<RwLock<...>>;读多写少;解释为什么不用 Mutex |
3 小时 |
| 观察者模式 | 设计一个 EventEmitter,多个订阅者监听事件 |
用 Rc<RefCell<Vec<Box<dyn Fn()>>>>;单线程场景 |
3 小时 |
| 树形结构 | 设计一个文件树,父到子 Rc、子到父 Weak |
强计数能归零;无内存泄漏 | 4 小时 |
| 安全抽象封装 | 把一段 unsafe 裸指针操作封装成安全 API,加 SAFETY: 注释 |
对外暴露安全函数;unsafe 块内有完整 SAFETY 注释 |
4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
error[E0072]: recursive type List has infinite size |
递归类型没用 Box |
看枚举变体 | 用 Box<List> 包一层 |
error[E0277]: Rc<...> cannot be sent between threads safely |
把 Rc 跨线程传 |
看线程参数 | 改用 Arc |
thread panicked at 'already borrowed: BorrowMutError' |
同时两个 RefCell::borrow_mut |
看两个 borrow_mut 调用栈 | 用 try_borrow_mut;或重构借用作用域 |
| 程序卡死不动 | 死锁 | 用 std::thread::sleep 复现;看锁获取顺序 |
统一所有线程的锁获取顺序 |
PoisonError |
持锁线程 panic,锁中毒 | 看 panic 栈 | .lock().unwrap_or_else(|e| e.into_inner()) |
内存泄漏,Drop 不被调用 |
两个 Rc/Arc 互相强引用 |
看数据结构里是否有双向强引用 | 反向引用改用 Weak |
全局变量用 static mut 报 unsafe |
全局可变静态是未定义行为温床 | 看 static 声明 | 改用 LazyLock 或 Mutex |
unsafe 代码没有 SAFETY: 注释 |
违反安全抽象约定 | 看 unsafe 块 |
在 unsafe 块前写 // SAFETY: ... |
八、出口条件
全部勾选后再进入 阶段 5 并发与异步。
- [ ] 能写出
Box<T>的递归类型,解释为什么Box是必须的 - [ ] 能解释
Rc<T>与Arc<T>的引用计数开销,说出什么时候选Arc - [ ] 能写出
Rc<RefCell<T>>并解释运行时借用检查,复现borrow_mut双重借用 panic - [ ] 能写出
Arc<Mutex<T>>并解释死锁是怎么发生的,用一致的锁顺序避免 - [ ] 能解释
Weak是怎么打破循环引用的 - [ ] 能解释
Cow<T>的用途,以及OnceCell/LazyLock的初始化场景 - [ ] 能说出
Rc<RefCell<T>>与Arc<Mutex<T>>的分工判断依据(单线程共享可变 vs 跨线程) - [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径
自测题(先自己想,再看要点):
- 为什么 Rust 的递归类型必须用
Box?- 要点:Rust 的类型大小必须在编译期确定;递归类型直接包含自身会导致无穷大小;
Box是指针,大小固定,提供了一层间接。
- 要点:Rust 的类型大小必须在编译期确定;递归类型直接包含自身会导致无穷大小;
Rc与Arc的区别,什么时候选哪个?- 要点:Rc 是单线程引用计数,用非原子操作,不能跨线程;Arc 是跨线程版本,用原子操作;单线程共享用 Rc(开销小),跨线程共享用 Arc。
RefCell与Mutex的区别?- 要点:RefCell 是单线程运行时借用检查,冲突时 panic;Mutex 是跨线程操作系统锁,冲突时阻塞,中毒时返回 Err。
- 死锁怎么避免?
- 要点:所有线程以相同顺序获取多把锁;避免持锁时再调用未知代码;用
try_lock加超时降级。
- 要点:所有线程以相同顺序获取多把锁;避免持锁时再调用未知代码;用
Weak是怎么打破循环引用的?- 要点:Weak 不增加强引用计数;父节点 drop 时强计数归零,子节点也 drop,Weak::upgrade 返回 None。
Rc<RefCell<T>>与Arc<Mutex<T>>怎么选?- 要点:单线程共享可选用前者(运行时借用检查,冲突 panic);跨线程共享可选用后者(操作系统锁,冲突阻塞)。
Cow<T>解决了什么问题?- 要点:默认借用零拷贝,需要修改时才克隆;避免了「要么强制可变参数、要么每次深拷贝」的二选一。