智能指针对比 Box/Rc/Arc/RefCell
面试题
请对比 Rust 中 Box、Rc、Arc、RefCell 四种智能指针的用途、区别和适用场景。
考察意图
智能指针是 Rust 中管理堆内存和实现特殊所有权模式的核心工具。面试官希望候选人能清楚地区分四种指针的语义、线程安全性、运行时开销,以及它们组合使用的场景(如 Arc<Mutex<T>>)。
答题要点
四种智能指针对比
| 特性 | Box<T> | Rc<T> | Arc<T> | RefCell<T> |
|---|---|---|---|---|
| 所有权 | 唯一所有权 | 共享所有权 | 共享所有权 | 唯一所有权 |
| 线程安全 | 是(Send + Sync) | 否 | 是(Send + Sync) | 否 |
| 引用计数 | 无 | 有(非原子) | 有(原子) | 无 |
| 可变性 | 遵循编译期规则 | 不可变 | 不可变 | 运行时借用检查 |
| 运行时开销 | 堆分配 | 引用计数 | 原子引用计数 | 借用状态追踪 |
| 典型用途 | 堆分配、递归类型 | 单线程共享数据 | 多线程共享数据 | 内部可变性 |
Box<T>
fn main() {
// Box:最简单的智能指针,将数据分配到堆上
// 唯一所有权,编译期借用检查
// 用途一:固定大小的堆分配
let boxed = Box::new(42);
println!("Box: {}", boxed);
// 用途二:递归类型(编译器需要知道类型大小)
// 不用 Box:编译错误(无限大小)
// enum List { Cons(i32, List), Nil }
enum List {
Cons(i32, Box<List>),
Nil,
}
let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
println!("递归链表创建成功");
// 用途三:trait object
let animal: Box<dyn std::fmt::Debug> = Box::new("cat");
println!("trait object: {:?}", animal);
// Box 的解引用是透明的
let b = Box::new(String::from("hello"));
println!("长度: {}", b.len()); // 自动解引用
}Rc<T>
use std::rc::Rc;
fn main() {
// Rc:引用计数的共享所有权(单线程)
// 多个 Rc 指向同一数据,最后一个 Rc 被 drop 时释放数据
let data = Rc::new(vec![1, 2, 3]);
// clone 增加引用计数(不复制数据)
let data2 = Rc::clone(&data);
let data3 = Rc::clone(&data);
println!("引用计数: {}", Rc::strong_count(&data)); // 3
println!("data: {:?}", data);
println!("data2: {:?}", data2);
drop(data2);
println!("drop 后引用计数: {}", Rc::strong_count(&data)); // 2
// Rc 是不可变的,不能直接获取 &mut T
// 需要内部可变性(RefCell)配合
}Arc<T>
use std::sync::Arc;
use std::thread;
fn main() {
// Arc:原子引用计数的共享所有权(多线程安全)
// 与 Rc 类似,但使用原子操作维护引用计数
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let mut handles = vec![];
for i in 0..3 {
let data_clone = Arc::clone(&data);
let handle = thread::spawn(move || {
// 每个线程都有自己的 Arc,共享底层数据
println!("线程 {}: {:?}", i, data_clone);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("主线程引用计数: {}", Arc::strong_count(&data));
}RefCell<T>
use std::cell::RefCell;
fn main() {
// RefCell:运行时借用检查,提供内部可变性
// 在拥有不可变引用时仍可修改数据
let data = RefCell::new(vec![1, 2, 3]);
// borrow() 返回 Ref<T>(不可变借用)
{
let borrowed = data.borrow();
println!("读取: {:?}", *borrowed);
} // Ref 离开作用域,借用释放
// borrow_mut() 返回 RefMut<T>(可变借用)
{
let mut borrowed = data.borrow_mut();
borrowed.push(4);
println!("修改后: {:?}", *borrowed);
}
// 运行时违反借用规则会 panic
// let r1 = data.borrow();
// let r2 = data.borrow_mut(); // panic: already borrowed
// try_borrow / try_borrow_mut 返回 Result,不会 panic
if let Ok(r) = data.try_borrow() {
println!("安全借用: {:?}", *r);
}
}组合使用
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
fn main() {
// === Rc<RefCell<T>>:单线程共享可变数据 ===
let shared = Rc::new(RefCell::new(vec![1, 2, 3]));
let ref1 = Rc::clone(&shared);
let ref2 = Rc::clone(&shared);
ref1.borrow_mut().push(4);
ref2.borrow_mut().push(5);
println!("Rc<RefCell>: {:?}", shared.borrow());
// === Arc<Mutex<T>>:多线程共享可变数据 ===
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..5 {
let counter_clone = Arc::clone(&counter);
let handle = std::thread::spawn(move || {
let mut num = counter_clone.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Arc<Mutex>: {}", *counter.lock().unwrap());
}常见追问
追问一:Rc 为什么不是线程安全的?
Rc 的引用计数使用普通的整数递增/递减操作,在多线程环境下会产生数据竞争。Arc 使用原子操作(atomic)维护引用计数,保证线程安全,但原子操作有额外的性能开销。
追问二:RefCell 和 Mutex 有什么区别?
RefCell 是单线程的运行时借用检查,Mutex 是多线程的互斥锁。RefCell 违反规则会 panic,Mutex 会阻塞等待。RefCell 不能跨线程,Mutex 可以。
追问三:Weak 引用是什么?
Weak 是 Rc/Arc 的弱引用版本,不增加强引用计数。主要用于打破循环引用。upgrade() 返回 Option<Rc<T>>,如果数据已释放则为 None。
基本示例
use std::cell::RefCell;
use std::rc::{Rc, Weak};
// 树结构:父子关系需要共享所有权
#[derive(Debug)]
struct Node {
value: i32,
parent: RefCell<Weak<Node>>, // 弱引用避免循环引用
children: RefCell<Vec<Rc<Node>>>, // 强引用拥有子节点
}
fn main() {
let leaf = Rc::new(Node {
value: 3,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![]),
});
let branch = Rc::new(Node {
value: 5,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![Rc::clone(&leaf)]),
});
// 设置父节点(弱引用)
*leaf.parent.borrow_mut() = Rc::downgrade(&branch);
// 通过弱引用访问父节点
if let Some(parent) = leaf.parent.borrow().upgrade() {
println!("leaf 的父节点值: {}", parent.value);
}
println!("branch 强引用计数: {}", Rc::strong_count(&branch));
println!("branch 弱引用计数: {}", Rc::weak_count(&branch));
}常见问题
问题一:什么时候用 Box 什么时候用 Rc?
只有一个所有者用 Box,需要多个所有者共享同一份数据用 Rc。如果不确定,先用 Box 或普通所有权,只有确实需要共享时才用 Rc。
问题二:Cell 和 RefCell 有什么区别?
Cell<T> 通过替换整个值实现内部可变性(get/set),适用于 Copy 类型。RefCell<T> 通过运行时借用检查实现,支持引用访问,适用于任意类型。
适用场景
- Box:递归类型、trait object、大数据堆分配
- Rc:单线程中的图结构、观察者模式
- Arc:多线程共享只读数据
- RefCell:需要在不可变上下文中修改数据
注意事项
- Rc 不能跨线程,用 Arc 替代
- RefCell 违反借用规则会 panic(运行时)
- Rc 的循环引用会导致内存泄漏,用 Weak 打破
- Arc<Mutex<T>> 是多线程共享可变数据的标准模式
- Box 的开销最小,只有堆分配
- 优先用编译期检查,RefCell 是最后手段
总结
Box 提供唯一所有权的堆分配,用于递归类型和 trait object。Rc 提供单线程引用计数共享所有权,Arc 是其多线程版本(原子操作)。RefCell 提供运行时借用检查的内部可变性。组合模式:Rc<RefCell<T>> 用于单线程共享可变数据,Arc<Mutex<T>> 用于多线程共享可变数据。Weak 引用打破 Rc/Arc 的循环引用。优先使用编译期检查,只有在编译期规则过于限制时才使用 RefCell。