智能指针对比 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> ​

rust
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> ​

rust
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> ​

rust
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> ​

rust
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);
    }
}

组合使用 ​

rust
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。

基本示例 ​

rust
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。