04.4.1.3 智能指针与内部可变性
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.1 所有权与类型系统
04.4.1.3-001 智能指针与普通引用有什么区别?
一句话结论
普通引用 &T/&mut T 只做借用、无所有权与额外元数据;智能指针是持有(或代理)所有权的类型,通过 Deref 暴露内部值,并在 drop 时执行释放逻辑。
概念解释
智能指针在指针之外携带计数、标志、内部可变性等元数据。标准库代表有 Box、Rc、Arc、RefCell、Cow、Pin。它们实现 Deref 让访问像引用,实现 Drop 定义释放行为。
原理流程
- 智能指针持有堆上或包装的数据。
Deref提供到内部类型的访问。- 指针丢弃时
Drop释放资源或减少计数。
代码或图示
let b = Box::new(10);
assert_eq!(*b, 10); // Deref 解引用
常见误区
- 以为智能指针一定指向堆:多数标准库智能指针如此,但概念上是“带行为的指针/包装”。
- 以为智能指针都能跨线程:
Rc/RefCell不是线程安全,跨线程用Arc/Mutex。
追问
- 智能指针必须实现哪两个 trait?答:通常
Deref(访问内部值)与Drop(释放逻辑);可变访问场景再加DerefMut。 - 引用计数指针和 Box 最大差别?答:Box 单一所有权,Rc/Arc 允许多所有者共享。
04.4.1.3-002 Box<T> 适用哪些场景?
一句话结论
Box<T> 用于堆分配、单一所有权:递归类型、大小编译期不确定的值、大体型值想避免栈拷贝,以及把 trait object 放进堆上。
概念解释
Box 在栈上存指针,堆上存值。递归枚举(链表/树)节点大小无法静态确定,必须用 Box 打断递归;返回 trait object 也常装箱到 Box。
原理流程
Box::new(v)分配堆内存并移入值。- 通过 Deref 访问。
- Box drop 时释放堆内存。
代码或图示
enum Tree {
Leaf(i32),
Node(Box<Tree>, Box<Tree>),
}
常见误区
- 以为小对象也该套 Box:栈上直接持有更省一次间接访问。
- 以为 Box 可被多个变量共享:它独占所有权,共享用 Rc/Arc。
追问
- 递归类型为什么必须指针?答:直接递归会让类型大小无限嵌套,编译器无法计算栈帧;指针大小固定,堆上节点可递归。
- Box 释放会调用内部值的 Drop 吗?答:会,先 drop 内部值,再释放堆内存。
04.4.1.3-003 Rc<T> 引用计数怎么工作?
一句话结论
Rc<T> 在堆上保存值与强/弱计数,Rc::clone 只增计数不克隆值;最后一个强引用丢弃时计数归零,值被释放。它只用于单线程。
概念解释
Rc 提供不可变共享所有权。强计数表示有效所有者,弱计数表示不阻止释放的观察引用。计数非原子,因此不是 Send/Sync。
原理流程
Rc::new分配值与计数,强计数为 1。- clone 增加强计数;丢弃 Rc 减一。
- 强计数归零 drop 值,弱计数随后清理控制块。
代码或图示
use std::rc::Rc;
let a = Rc::new(vec![1, 2]);
let b = Rc::clone(&a);
println!("{}", Rc::strong_count(&a)); // 2
常见误区
- 以为
Rc::clone深拷贝内部 Vec:只复制指针并加计数。 - 以为 Rc 可在多线程使用:计数非原子,跨线程会被编译器拒绝。
追问
- 强计数与弱计数用途?答:强计数决定是否释放;Weak 用于打破循环引用,升级为 Rc 才能访问。
- Rc 内部值能修改吗?答:Rc 只给不可变借用;需要共享可变配合
RefCell。
04.4.1.3-004 Weak<T> 如何打破循环引用?
一句话结论
Weak<T> 是不拥有所有权的弱引用,不增加强计数;图/树的父节点用强引用持有子节点,子节点用 Weak 指回父节点,避免强计数互相归零失败。
概念解释
两个 Rc 互相强引用时,强计数永远 ≥1,值无法释放形成泄漏。Weak 只观察目标,升级成功才拿到临时 Rc;目标已释放则升级返回 None。
原理流程
- 父节点
Rc<Node>持有子节点。 - 子节点存
Weak<Node>指回父。 - 父节点丢弃时强计数归零释放,子节点 Weak 随之失效。
代码或图示
use std::rc::{Rc, Weak};
struct Node { parent: Weak<Node>, children: Vec<Rc<Node>> }
let parent = Rc::new(Node { parent: Weak::new(), children: vec![] });
let child = Rc::new(Node { parent: Rc::downgrade(&parent), children: vec![] });
parent.children.push(child);
常见误区
- 以为 Weak 也阻止释放:Weak 不持有强所有权,不阻止 drop。
- 以为 Weak 可直接访问内部值:必须先
upgrade()得到Option<Rc<T>>。
追问
- 升级返回什么?答:
Option<Rc<T>>,目标存活则 Some,已释放则 None。 - 循环引用一定是 bug 吗?答:若生命周期本就与程序同寿,环可接受;否则应拆成 Weak 或重新设计所有权。
04.4.1.3-005 Arc<T> 与 Rc<T> 的区别?
一句话结论
Arc<T> 用原子操作维护引用计数,实现 Send + Sync,可跨线程共享;Rc<T> 用普通计数,仅限单线程。两者 API 几乎一致。
概念解释
Arc(Atomic Rc)的增减计数是原子操作,保证多线程下计数正确,代价是原子指令开销。多线程共享不可变数据用 Arc,共享可变数据再配 Mutex/RwLock。
原理流程
Arc::new分配值与原子计数。- clone 原子加计数,丢弃原子减计数。
- 计数归零在最后一个持有者线程释放。
代码或图示
use std::sync::Arc;
let a = Arc::new(42);
let b = Arc::clone(&a);
std::thread::spawn(move || println!("{}", b));
常见误区
- 以为 Arc 内部值可变:Arc 只共享不可变访问,可变需内部同步原语。
- 以为原子计数无开销:原子操作比普通整数贵,热点计数频繁场景需评估。
追问
Arc<Mutex<T>>各部分职责?答:Arc 提供跨线程共享所有权,Mutex 提供互斥可变访问。- 什么时候 Rc 比 Arc 合适?答:确定单线程、追求最低计数开销时用 Rc;跨线程一律 Arc。
04.4.1.3-006 RefCell<T> 的内部可变性与运行时借用检查是什么?
一句话结论
RefCell<T> 把借用检查从编译期推迟到运行时:对外是不可变引用,内部通过 borrow()/borrow_mut() 动态检查借用规则,违反时在运行时 panic。
概念解释
内部可变性允许在不可变引用下修改内部数据,前提是运行时仍遵守借用互斥。RefCell 记录当前借用数量:多个不可变或一个可变,冲突即 panic。
原理流程
borrow()取不可变借用,计数不可变 +1。borrow_mut()要求无可变借用且无不可变借用。- 借用守卫 drop 时计数回落;冲突触发
AlreadyBorrowed/AlreadyBorrowedMutpanic。
代码或图示
use std::cell::RefCell;
let cell = RefCell::new(vec![1, 2]);
cell.borrow_mut().push(3);
let r = cell.borrow();
println!("{:?}", r);
常见误区
- 以为 RefCell 绕过了安全规则:它只是把检查移到运行时,规则仍是多读单写。
- 以为 borrow 守卫可以长期持有跨函数传递:守卫存活期间计数不回落,容易冲突。
追问
- RefCell 是线程安全的吗?答:不是
Sync,不能跨线程共享;跨线程内部可变用Mutex/RwLock。 - 运行时 panic 能被 catch 吗?答:panic 默认终止线程/进程;可在边界用
catch_unwind捕获,但不应依赖它做常规错误处理。
04.4.1.3-007 RefCell 什么场景会 panic?
一句话结论
已存在可变借用时再 borrow_mut(),或已存在不可变借用时再 borrow_mut(),以及不可变借用未释放时重复可变借用,都会在运行时 panic。
概念解释
RefCell 内部状态分:未借用、多个不可变、一个可变。任何违反互斥的二次借用都直接 panic,而不是返回错误。
原理流程
- 记录当前借用类型与数量。
- 新借用与当前状态冲突 → panic。
- 守卫离开作用域后状态才更新。
代码或图示
let cell = RefCell::new(0);
let m = cell.borrow_mut();
// let _ = cell.borrow_mut(); // panic: AlreadyBorrowedMut
// let _ = cell.borrow(); // panic: AlreadyBorrowed
常见误区
- 以为把借用存进结构体字段就安全:字段守卫长期持有会阻止后续借用。
- 以为冲突会返回
Result:RefCell 借用方法直接返回守卫,冲突 panic。
追问
- 如何减少冲突?答:缩短借用守卫作用域,用完立即 drop;复杂结构先取出需要的值再释放借用。
- 有返回 Result 的替代吗?答:
try_borrow()/try_borrow_mut()返回Result<Ref/RefMut, BorrowError>,可在不确定状态时使用。
04.4.1.3-008 Rc<RefCell<T>> 与 Arc<Mutex<T>> 如何分工?
一句话结论
Rc<RefCell<T>> 用于单线程共享可变数据:Rc 多所有者,RefCell 运行时借用检查;Arc<Mutex<T>> 用于多线程:Arc 跨线程共享,Mutex 互斥同步。
概念解释
两者都是“共享所有权 + 内部可变”的组合,区别在线程边界。单线程用 Rc/RefCell 无原子开销;多线程必须 Arc/锁,借用检查由锁在运行时保证。
原理流程
- 判断是否跨线程:否 → Rc + RefCell;是 → Arc + Mutex/RwLock。
- 共享所有权由外层指针负责。
- 可变访问由内层同步/借用类型负责。
代码或图示
// 单线程
use std::rc::Rc; use std::cell::RefCell;
let a = Rc::new(RefCell::new(vec![]));
// 多线程
use std::sync::{Arc, Mutex};
let b = Arc::new(Mutex::new(vec![]));
常见误区
- 以为 Rc
能放进线程:Rc 不是 Send,编译拒绝。 - 以为 Mutex 内部数据可直接读:必须
lock()拿守卫,通过守卫访问。
追问
- 读多写少的多线程场景用什么?答:
Arc<RwLock<T>>,读并发、写独占;注意写饥饿与平台实现差异。 - 组合里哪一层决定线程安全?答:外层 Rc/Arc 决定所有权跨线程能力,内层 RefCell/Mutex 决定可变访问同步方式。
04.4.1.3-009 什么是内部可变性?
一句话结论
内部可变性(interior mutability)指在持有不可变引用的前提下修改内部数据,由 Cell/RefCell/Mutex/RwLock 等类型在编译期或运行时保证别名规则不被破坏。
概念解释
普通规则是“不可变引用下不能改”。内部可变性把可变性收进类型内部,对外暴露 &T,修改动作经过类型自己的检查/同步。它是对默认别名规则的受控例外。
原理流程
- 外部拿到不可变引用。
- 修改请求经内部类型的检查(编译期 Copy 替换或运行时借用/锁)。
- 检查通过才写入,违反规则在编译期或运行时拦截。
代码或图示
use std::cell::Cell;
let x = Cell::new(1);
let y = &x;
y.set(2); // 不可变引用下修改内部值
assert_eq!(x.get(), 2);
常见误区
- 以为内部可变性可以随意共享可变:仍受别名/互斥约束,只是检查位置不同。
- 以为所有场景都该用内部可变性:默认应遵循所有权与借用,确有共享可变需求再用。
追问
- 标准库哪些类型提供内部可变性?答:
Cell、RefCell(单线程),Mutex、RwLock、Atomic*(多线程)。 - 内部可变性与
&mut T相比代价?答:放弃编译期独占保证,换取共享访问;可能运行时冲突或加锁开销。
04.4.1.3-010 Cell<T> 与 RefCell<T> 的区别?
一句话结论
Cell<T> 适用于 Copy 类型,通过整体替换 set 修改,不返回内部引用;RefCell<T> 可返回 Ref/RefMut 借用守卫,适合非 Copy 类型与需要引用访问的场景。
概念解释
Cell 不暴露内部引用,避免别名问题,只能读出来、改完写回;RefCell 运行时维护借用计数,可借出借入引用。两者都不是线程安全。
原理流程
- Copy 类型优先 Cell:
get()复制值,set()整体替换。 - 需要持有内部引用或非 Copy 类型用 RefCell。
- 借用守卫离开作用域回落计数。
代码或图示
let c = Cell::new(3);
c.set(c.get() + 1);
let r = RefCell::new(String::from("x"));
r.borrow_mut().push_str("y");
常见误区
- 以为 Cell 能存任意类型并返回引用:Cell 不提供
borrow_mut,非 Copy 类型用 RefCell。 - 以为 Cell/RefCell 可跨线程:均不是 Sync。
追问
- 标准库哪里用 Cell?答:如
Cell<u32>计数字段、UnsafeCell是二者的底层基础。 UnsafeCell是什么?答:内部可变性的底层原语,告诉编译器该类型内部可变;高级类型在其上封装安全接口。
04.4.1.3-011 Drop trait 与析构顺序是什么?
一句话结论
实现 Drop 可在值被释放时执行清理(关句柄、落盘、通知);drop 按“字段声明顺序的逆序”释放,嵌套值先内层后外层,作用域内局部变量按声明逆序 drop。
概念解释
Drop::drop 不能手动直接调用,调用 drop(value) 只是提前丢弃值。实现 Drop 的类型不能同时是 Copy。析构是确定性的,不依赖 GC。
原理流程
- 值离开作用域或被移动出作用域。
- 编译器插入 drop:先调
Drop::drop自定义逻辑。 - 字段按声明逆序逐个 drop,再释放内存。
代码或图示
struct FileLike;
impl Drop for FileLike {
fn drop(&mut self) { println!("cleanup"); }
}
{
let _f = FileLike;
} // 离开作用域输出 cleanup
常见误区
- 以为可以在
drop里阻止释放:drop是最后机会,不能取消析构。 - 以为字段按声明顺序释放:实际是逆序,与构造顺序相反。
追问
- 如何提前释放值?答:调用标准库
std::mem::drop(value),不要自己写同名遮蔽函数。 - Drop 里可能 panic 吗?答:应避免;析构中 panic 会中断后续清理,关键资源要设计成幂等可重试。
04.4.1.3-012 循环引用为什么会导致内存泄漏?
一句话结论
Rc/Arc 构成强引用环时,每个节点被另一节点强引用,强计数永不归零,值无法 drop,形成泄漏;Rust 没有 GC 自动打破这种环。
概念解释
引用计数只在强计数归零时释放,环中计数互相牵制。泄漏不违反内存安全,但资源长期占用。解决方式是用 Weak 断开环,或改用所有权清晰的树结构。
原理流程
- 两个节点互相 Rc/Arc 强引用。
- 外部引用移除后,节点间仍各持一份强计数。
- 计数 ≥1,不触发 drop,控制块与内容常驻。
代码或图示
// 反例:A 持 Rc<B>,B 持 Rc<A>,形成环
// 修正:一侧改为 Weak,不持有强所有权
常见误区
- 以为 Rust 不可能内存泄漏:GC 语言也会泄漏,Rc/Arc 环、未清理缓存、泄漏的句柄都可能占用资源。
- 以为弱引用也参与计数归零判断:Weak 不计入强释放条件。
追问
- 如何排查引用环?答:画所有权关系图,找出双向强引用;用
strong_count辅助观察,必要时引入 Weak。 - 除了引用环还有哪些泄漏源?答:无界缓存/队列只增不减、闭包长期持有大对象、忘记关闭的句柄、线程未退出持有资源。
04.4.1.3-013 Cow<'a, B> 是什么?
一句话结论
Cow(Clone on Write)表示“能借用就借用,需要修改时才克隆”的智能指针:要么持有 &'a B 借用,要么持有 owned B,通过 to_mut() 在写入时按需克隆。
概念解释
Cow 用于返回值可能是借用切片也可能需要自有副本的场景,避免无差别深拷贝。B 通常为 str 或 [T]。
原理流程
- 构造时传入借用或 owned 值。
- 只读访问统一走 Deref。
- 需要可变时
to_mut():若为借用则克隆成 owned,已 owned 直接返回可变引用。
代码或图示
use std::borrow::Cow;
fn trim(s: &str) -> Cow<'_, str> {
if s.starts_with(' ') { Cow::Owned(s.trim().to_owned()) }
else { Cow::Borrowed(s) }
}
常见误区
- 以为 Cow 一定会克隆:只读路径保持借用,零拷贝。
- 以为 Cow 内部可直接修改借用:修改必须经
to_mut()触发克隆。
追问
- Cow 的生命周期参数
'a约束什么?答:借用分支必须活过'a;owned 分支不受该借用约束。 - 标准库哪里返回 Cow?答:字符串/切片处理、路径规范化等“可能改也可能不改”的 API。
04.4.1.3-014 常用引用转换方法有哪些?
一句话结论
as_ref()/as_mut() 在不转移所有权的前提下借用内部值,as_slice()/as_str() 转视图,into_boxed_slice() 把 Vec 收窄为堆切片;转换遵循借用规则。
概念解释
标准库为容器提供一组“借用转视图”方法,避免克隆。Into/From 负责所有权转换,as_ref/as_mut 负责临时借用转换。
原理流程
- 需要只读视图调
as_ref()/as_str()。 - 需要临时可改写
as_mut()。 - 需要独立堆切片用
into_boxed_slice()(消费原 Vec)。
代码或图示
let v = vec![1, 2, 3];
let s: &[i32] = v.as_slice();
let b: Box<[i32]> = v.into_boxed_slice();
常见误区
- 以为
as_ref会复制内部值:它只返回借用视图。 - 以为
into_*不消耗所有权:into系列通常消费 self,转换后原绑定失效。
追问
as_ref与deref区别?答:as_ref是显式转换到关联引用类型,Deref是解引用穿透;两者常配合使用。- 字符串转字节用什么?答:
as_bytes()得到&[u8],反向from_utf8校验后构造&str/String。
04.4.1.3-015 Pin<P> 解决什么问题?
一句话结论
Pin<P> 保证包装的值在内存中不会被移动,用于自引用结构与 Future:固定地址后内部指针/状态引用才不会因移动失效。
概念解释
普通值移动后栈/堆地址变化,自引用字段(指向自身另一字段的指针)会悬垂。Pin 通过类型系统禁止取得 &mut T 随意移动,把固定约束显式化。Future 状态机常需要被固定在内存中轮询。
原理流程
Box::pin(v)在堆上固定值,返回Pin<Box<T>>。- 固定后不能把值移出或随意换址。
- 自引用指针在固定地址上保持有效。
代码或图示
use std::pin::Pin;
let future = async { 1 };
let pinned = Box::pin(future); // 固定 Future 以便轮询
常见误区
- 以为 Pin 自己阻止所有移动:它依赖包装指针类型(Box/Arc)与 unsafe 约定保证地址稳定。
- 以为普通结构体都需要 Pin:仅自引用或被异步状态机固定的值需要。
追问
- 哪些类型实现
Unpin?答:绝大多数普通类型自动实现Unpin,表示“被固定也没关系”;含自引用的类型通常!Unpin。 - 为什么 async fn 返回的 Future 需要 Pin?答:状态机内部可能跨 await 持有自引用,轮询器必须在固定地址上 poll。
04.4.1.3-016 多层 Deref 链如何穿透?
一句话结论
访问方法/字段时编译器按 Deref::Target 逐层向上穿透,Box<Arc<RefCell<T>>> 可最终访问到内部 T;链式 Deref 在方法解析与 deref coercion 中自动发生。
概念解释
每个智能指针声明自己的 Target,多层包装形成链。解引用 ***p 或方法调用时,编译器沿链找到提供该方法的类型。
原理流程
- 从外层指针开始读
Deref::Target。 - 目标不匹配继续下一层。
- 找到方法所在类型,插入解引用调用。
代码或图示
use std::sync::Arc; use std::cell::RefCell;
let x = Arc::new(RefCell::new(String::from("hi")));
assert_eq!(x.borrow().as_str(), "hi");
常见误区
- 以为多层包装必须手写多次
*:方法调用与 deref coercion 可自动穿透。 - 以为链上每一层都可安全解引用:内部可变/借用冲突仍按各自规则检查。
追问
- 可变穿透走哪个 trait?答:
DerefMut,需要外层提供&mut可访问性。 - 链过长有什么问题?答:阅读成本高、冲突点多;设计时尽量减少嵌套包装。
04.4.1.3-017 Box::leak 什么时候使用,后果是什么?
一句话结论
Box::leak 把 Box 转成 &'static mut T 并故意不释放,用于程序生命周期内一直存活的数据;后果是该内存常驻,必须确认业务上确实长期需要。
概念解释
正常 drop 释放堆内存,leak 主动放弃所有权管理。常见于跨生命周期注册、静态表项等场景;滥用会造成内存常驻,等价于有意泄漏。
原理流程
Box::new(v)分配堆值。Box::leak取走原始指针并放弃析构注册。- 数据以
'static可变引用存在,直到进程退出。
代码或图示
let leaked: &'static mut String = Box::leak(Box::new(String::from("cfg")));
常见误区
- 以为 leak 后还能再收回:常规路径无法 drop,需通过 unsafe 从指针重建 Box 才能释放。
- 以为泄漏一定是错误:程序级常驻缓存可接受,但应在代码里注明意图。
追问
- 与
static常量区别?答:leak 是运行时分配的'static可变数据;static是编译期布局的全局项,可变访问需同步/unsafe。 - 如何避免无意 leak?答:审查
Box::leak、Rc/Arc环、只增不减的集合,上线前做内存曲线观察。
04.4.1.3-018 为什么 Rc 不是 Send/Sync,RefCell 不是 Sync?
一句话结论
Rc 的引用计数非原子,跨线程增减会产生计数竞争,因此不实现 Send/Sync;RefCell 的借用计数无同步保护,被多线程共享引用会产生数据竞争,因此不实现 Sync。
概念解释
Send 表示可转移线程所有权,Sync 表示 &T 可跨线程共享。内部含非原子可变状态的类型无法保证线程安全,编译器自动不实现这两个标记 trait。
原理流程
- 类型内部状态是否线程安全由结构决定。
- 含非原子计数/借用计数 → 自动不实现对应标记。
- 跨线程使用时编译器按 Send/Sync 报错拦截。
代码或图示
// std::rc::Rc 不是 Send/Sync
// std::cell::RefCell 不是 Sync
// 跨线程共享:Arc<Mutex<T>> / Arc<RwLock<T>>
常见误区
- 以为把 Rc 包进 Arc 就能解决:问题在内部非原子计数,包装无法消除竞争。
- 以为 RefCell 可以只读共享:
&RefCell可在单线程共享,但跨线程共享引用被 Sync 规则拒绝。
追问
- 如何确认一个类型是否 Send/Sync?答:写泛型约束或尝试
std::thread::spawn传递,编译器错误会说明缺哪个标记。 - 原子类型为什么能跨线程?答:
AtomicUsize等用原子指令同步内部状态,实现了对应 Send/Sync。