Rust 智能指针选型:Box、Rc、Arc 什么时候该用哪一个
堆上放还是栈上放?一个人用还是多人用?单线程还是多线程?这三个问题答对了,智能指针就不会选错。
一、每次 cargo check 报错,都在拷问我:到底用 Box、Rc 还是 Arc?
刚学 Rust 那段时间,我最怕的错误不是编译不过,而是编译过了,但自己心里没底——这个 Box 该不该换成 Rc?这里 Rc 换成 Arc 是不是浪费?编辑器里红色波浪线没了,但代码质量怎么样,自己都不敢拍胸脯。
一开始我只是机械地记住几条"口诀":递归类型用 Box、多所有权用 Rc、多线程用 Arc。可真遇到实际场景,就不是那回事了。比如我在写一个简单的命令行工具,解析完配置后要传给多个模块用,这时候 Rc 看起来合情合理,但回头一想——clone() 一次引用计数就加一,真的比直接传引用更合适吗?再比如读一个同事用 Arc<Mutex<Vec<T>>> 的场景,我没见过一个写操作,心里犯嘀咕:既然全是读,为什么不用 Arc<Vec<T>> 直接共享不可变引用?
这些困惑,促使我彻底理清三种智能指针的底层机制和真实使用边界。这篇文章就是我的复盘笔记,希望能给同样在 Rust 所有权迷宫里转圈的朋友一点参考。
核心问题其实就三个维度:
- 数据要放在堆上还是栈上? 大对象、递归结构、trait 对象的动态分发,都离不开堆分配。
- 数据有几个人"拥有"? 独占所有权用 Box,多人共享用 Rc 或 Arc。
- 数据会不会跨线程? 不跨线程用 Rc,跨线程必须上 Arc。
这三个问题问对了方向,选型就八九不离十了。
二、一张图看懂三种指针的内存布局差异
在讲代码之前,先把内存模型搞清楚。下面这张图展示了 Box<T>、Rc<T> 和 Arc<T> 在堆上的结构差异:
graph TB
subgraph Stack["栈内存"]
B["Box<T> = 指针(8字节)"]
R["Rc<T> = 指针(8字节)"]
A["Arc<T> = 指针(8字节)"]
end
subgraph HeapBox["堆内存 - Box"]
T1["T 数据本体"]
end
subgraph HeapRc["堆内存 - Rc"]
RC["强引用计数 strong_count"]
WC["弱引用计数 weak_count"]
T2["T 数据本体"]
end
subgraph HeapArc["堆内存 - Arc"]
AS["原子强引用计数 (AtomicUsize)"]
AW["原子弱引用计数 (AtomicUsize)"]
T3["T 数据本体"]
end
B -->|指向| T1
R -->|指向| RC
A -->|指向| AS
style Stack fill:#e1f5fe,stroke:#0288d1
style HeapBox fill:#c8e6c9,stroke:#388e3c
style HeapRc fill:#fff9c4,stroke:#fbc02d
style HeapArc fill:#ffccbc,stroke:#e64a19
三种指针在栈上都只占用 一个指针大小(8 字节在 64 位系统上),区别全在堆里:
Box<T>最简洁,堆上只有T本身,没有任何额外开销。Box 就是"指向堆的独占指针",语义和 C++ 的unique_ptr类似。Rc<T>额外存储了strong_count和weak_count两个计数字段(各usize),然后才是T本身。clone()时只需对strong_count做+1,这是普通的整数加法,开销很小。Arc<T>同样存储两个计数,但类型是AtomicUsize。clone()时要用 原子指令(如 x86 的lock inc),这比普通的+1要慢几十个 CPU 周期,还会引发缓存一致性协议通信。
把这个图记在脑子里,后面选型的理由就自然浮现了。
三、三个真实场景,看看生产环境里怎么选
以下代码示例均从实际项目经验中提炼,注释已汉化方便阅读。
场景 1:递归数据结构(二叉搜索树)
Rust 编译时必须知道每个类型的大小,递归结构的大小在编译期无法确定,所以必须用指针"打破"这个循环。
// ✅ 正确:用 Box 提供间接层,编译期大小 = 指针大小
struct TreeNode {
val: i32,
left: Option<Box<TreeNode>>, // Box 让 left 的大小固定为 8 字节
right: Option<Box<TreeNode>>, // 而不是无限递归的 TreeNode 大小
}
impl TreeNode {
fn insert(&mut self, val: i32) {
if val < self.val {
match self.left {
Some(ref mut left) => left.insert(val),
None => self.left = Some(Box::new(TreeNode {
val,
left: None,
right: None,
})),
}
} else {
match self.right {
Some(ref mut right) => right.insert(val),
None => self.right = Some(Box::new(TreeNode {
val,
left: None,
right: None,
})),
}
}
}
}
// ❌ 如果写成 Option<TreeNode>,编译器会报:
// "recursive type has infinite size"
选型理由:树节点之间有严格的父子关系,每个子节点只属于一个父节点,是毋庸置疑的独占所有权,Box 最合适。如果用 Rc 反而是过度设计——计数和弱引用在这里完全用不上。
场景 2:配置对象被多个模块共享(单线程)
一个配置文件解析后,需要传给日志模块、数据库连接池、业务逻辑层等多个模块使用:
use std::rc::Rc;
// 应用配置结构体
struct AppConfig {
db_url: String,
log_level: String,
max_connections: u32,
}
// 日志模块:只读取配置,不修改
struct Logger {
config: Rc<AppConfig>, // 共享只读引用
}
impl Logger {
fn log_level(&self) -> &str {
&self.config.log_level
}
}
// 数据库连接池:同样只需要读取
struct DbPool {
config: Rc<AppConfig>,
}
impl DbPool {
fn max_conn(&self) -> u32 {
self.config.max_connections
}
}
fn main() {
let config = Rc::new(AppConfig {
db_url: String::from("postgres://localhost/mydb"),
log_level: String::from("debug"),
max_connections: 10,
});
let logger = Logger {
config: Rc::clone(&config), // 引用计数 +1,不复制数据
};
let pool = DbPool {
config: Rc::clone(&config), // 引用计数 +1,不复制数据
};
// config 仍然有效,三个持有者都可以访问
println!("日志级别: {}", logger.log_level());
println!("最大连接数: {}", pool.max_conn());
// config 超出作用域时,strong_count 从 3 逐减到 0,数据被释放
}
选型理由:配置全生命周期只读不写,多个模块需要共享同一份数据,且程序是单线程(或只在主线程使用),Rc<AppConfig> 是最轻量级的共享方案。如果强行用 &AppConfig + 生命周期标注,参数链条会变得非常丑陋,而且生命周期标注会"传染"给所有使用配置的结构体。
什么时候用引用代替 Rc? 如果共享者之间的生命周期关系清晰(比如 A 一定比 B 活得久),那用引用 &T 更合适,零开销。Rc 的本质是"生命周期不确定时的引用替代品"。
场景 3:多线程共享只读数据
把场景 2 的配置搬到多线程环境,Rc 就不行了——Rc 没有实现 Send trait,编译器会在编译期直接拦下来:
use std::sync::Arc;
use std::thread;
struct AppConfig {
db_url: String,
log_level: String,
}
fn main() {
let config = Arc::new(AppConfig {
db_url: String::from("postgres://localhost/mydb"),
log_level: String::from("debug"),
});
let mut handles = vec![];
// 启动 4 个线程,每个线程都持有 config 的 Arc 引用
for i in 0..4 {
// Arc::clone 是原子操作,线程安全
let cfg = Arc::clone(&config);
handles.push(thread::spawn(move || {
println!("线程 {} 读取日志级别: {}", i, cfg.log_level);
}));
}
for h in handles {
h.join().unwrap();
}
}
选型理由:跨线程共享只读数据,Arc<T> 是不二之选。引用计数的增减使用原子操作保证线程安全,虽然比 Rc 的性能开销略大,但在只读共享场景下,克隆通常只发生在线程创建时,不会成为热点。
场景 4:大对象转移所有权,避免栈拷贝
// 假设这是一个很大的结构体(几百字节甚至更大)
struct LargeData {
buffer: [u8; 1024 * 1024], // 1MB 数据
}
fn process_data(data: LargeData) {
// 如果直接传值,栈上会拷贝 1MB
// ...
}
fn main() {
let data = LargeData {
buffer: [0; 1024 * 1024],
};
// ✅ Box 让大对象在堆上分配,传递时只拷贝 8 字节指针
let boxed = Box::new(data);
process_boxed(boxed);
}
fn process_boxed(data: Box<LargeData>) {
// 接收到的是指针,不是数据拷贝
println!("处理了 {} 字节的数据", data.buffer.len());
}
选型理由:虽然 Rust 的 move 语义不会实际"复制"堆上的数据,但如果结构体本身就很大且直接在栈上分配,频繁的 move 仍然有栈拷贝开销。Box 把数据放到堆上,move 只需拷贝 8 字节指针。
四、决策不是拍脑袋——每种方案的代价和边界
性能开销对比
| 维度 | Box<T> | Rc<T> | Arc<T> |
|---|---|---|---|
| 堆上额外数据 | 无 | 2 × usize(强弱计数) | 2 × AtomicUsize |
| clone 开销 | 不支持(独占) | 普通整数加法 | 原子指令(lock inc/dec) |
| drop 开销 | 直接释放 | 计数值减 1 后判零释放 | 原子减 1 + 内存屏障 |
| 线程安全 | 可以 Send(T: Send) | 不能 Send/Sync | 可以 Send/Sync(T: Send + Sync) |
| 内存布局大小 | 栈上 8 字节 | 栈上 8 字节 | 栈上 8 字节 |
一个容易忽略的细节:Arc<T> 的 clone 开销虽然比 Rc<T> 大,但在现代 CPU 上仍然很小(几十纳秒级别)。只有在高频调用路径(比如每秒百万次 clone)中才需要特别关注。日常开发里,因为"怕原子操作太慢"而拒绝用 Arc,反而徒增设计复杂度。
适用场景速查
Box<T>:
- 递归数据结构(链表、树、图)
- Trait object:
Box<dyn Trait>实现运行时多态 - 大对象转移所有权,避免栈拷贝
- 需要在堆上分配但不想引入引用计数开销
Rc<T>:
- 单线程多所有权,典型的如事件监听器、DOM 树节点共享、图结构的节点引用
- 配合
RefCell<T>实现内部可变性:Rc<RefCell<T>> - 共享只读配置、缓存
Arc<T>:
- 多线程共享只读数据
- 配合
Mutex<T>/RwLock<T>实现线程间共享可变数据:Arc<Mutex<T>> - 异步编程(tokio 等)中的多任务共享
不适用场景和常见误区
- 不要用
Rc<RefCell<T>>代替好的架构设计:如果所有数据都套上Rc<RefCell>,代码就会变成"类 Java 式的共享可变状态",失去 Rust 在编译期保证安全的优势。频繁的borrow_mut()更容易在运行时 panic。 - 不要用
Arc<Mutex<T>>代替消息传递:如果数据流是单向的(生产者→消费者),用mpsc::channel传递所有权比共享锁更高效、更容易推理。 - 能传引用就别上 Rc:如果生命周期清晰,
&T是零开销的,Rc即使再便宜也是有代价的。
决策流程图
flowchart TD
Start["我需要管理一块数据的所有权"] --> Q1{"数据在编译期\n能确定大小吗?"}
Q1 -->|不能| Box["用 Box<T>"]
Q1 -->|能| Q2{"数据很大\n(>100 字节)?"}
Q2 -->|是| Box
Q2 -->|否| Q3{"数据被多个人\n共享持有?"}
Q3 -->|否,独占| Direct["栈上直接持有 T"]
Q3 -->|是| Q4{"会跨线程使用?"}
Q4 -->|否| Rc["用 Rc<T>"]
Q4 -->|是| Q5{"需要修改数据?"}
Q5 -->|否,只读| Arc["用 Arc<T>"]
Q5 -->|是| ArcLock["用 Arc<Mutex<T>>\n或 Arc<RwLock<T>>"]
style Start fill:#e3f2fd,stroke:#1565c0
style Box fill:#c8e6c9,stroke:#2e7d32
style Direct fill:#c8e6c9,stroke:#2e7d32
style Rc fill:#fff9c4,stroke:#f9a825
style Arc fill:#ffccbc,stroke:#d84315
style ArcLock fill:#ffccbc,stroke:#d84315
遵循这个决策树,90% 的场景都能一次选对。剩下 10% 的边界情况,需要结合具体性能测量来优化。
五、总结
写这篇文章的过程,也是我回顾自己从"死记硬背规则"到"理解底层模型"的转变过程。Rust 的三种智能指针,本质上不是什么高深的东西——它们只是在"堆栈选择、所有权个数、线程安全"三个维度上的排列组合。
- Box 代表"独占堆上所有权"——最简单,也最常用。递归类型、大对象、trait object 都用它。
- Rc 代表"单线程共享所有权"——入门容易,但别滥用。生命周期清晰的场景优先考虑
&T。 - Arc 代表"线程间共享所有权"——多线程编程的标配。它的 clone 开销比你想的小,别因为怕"原子操作慢"而绕弯子。
最后想说的一点是:智能指针是 Rust 所有权系统提供的安全网,而不是偷懒的借口。每当你准备写 Rc::clone 或 Arc::clone 的时候,停半秒想一想——这里的数据流向到底是怎样的?能不能用更简单的引用解决?这个习惯不大,但能让你的 Rust 代码更干净、更容易被人读懂。



被折叠的 条评论
为什么被折叠?



