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

11.5 阶段 4 智能指针与内部可变性

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

本页目录

一、阶段定位

阶段 2 给了你借用规则,阶段 3 给了你 trait 抽象。但在真实业务里,你会立刻遇到两个问题:

  1. 递归类型怎么办:List::Cons(i32, Box<List>)——不用 Box 包一层,编译器无法确定 List 的大小。
  2. 借用规则在某些场景下太严:你需要在「表面上不可变」的结构体内部修改字段,或在多个地方共享同一份数据且需要修改它。这就是内部可变性(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) 增加计数(不深拷贝);最后一个 Rc drop 时,内部数据 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 分钟内给出排查路径

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

  1. 为什么 Rust 的递归类型必须用 Box?
    • 要点:Rust 的类型大小必须在编译期确定;递归类型直接包含自身会导致无穷大小;Box 是指针,大小固定,提供了一层间接。
  2. Rc 与 Arc 的区别,什么时候选哪个?
    • 要点:Rc 是单线程引用计数,用非原子操作,不能跨线程;Arc 是跨线程版本,用原子操作;单线程共享用 Rc(开销小),跨线程共享用 Arc。
  3. RefCell 与 Mutex 的区别?
    • 要点:RefCell 是单线程运行时借用检查,冲突时 panic;Mutex 是跨线程操作系统锁,冲突时阻塞,中毒时返回 Err。
  4. 死锁怎么避免?
    • 要点:所有线程以相同顺序获取多把锁;避免持锁时再调用未知代码;用 try_lock 加超时降级。
  5. Weak 是怎么打破循环引用的?
    • 要点:Weak 不增加强引用计数;父节点 drop 时强计数归零,子节点也 drop,Weak::upgrade 返回 None。
  6. Rc<RefCell<T>> 与 Arc<Mutex<T>> 怎么选?
    • 要点:单线程共享可选用前者(运行时借用检查,冲突 panic);跨线程共享可选用后者(操作系统锁,冲突阻塞)。
  7. Cow<T> 解决了什么问题?
    • 要点:默认借用零拷贝,需要修改时才克隆;避免了「要么强制可变参数、要么每次深拷贝」的二选一。