Rust 的 Box、Rc、Arc 到底怎么选？

文章目录

• [Rust 的 Box、Rc、Arc 到底怎么选？](#Rust 的 Box、Rc、Arc 到底怎么选？)
• • 三者解决的是不同问题
  • • [Box：唯一所有权 + 堆分配](#Box：唯一所有权 + 堆分配)
    • Rc：单线程共享所有权
    • Arc：多线程共享所有权
  • 一表讲清三者关系
  • [Box 使用场景](#Box 使用场景)
  • • 场景一：递归类型（链表/树）
    • [场景二：trait object（特征对象）动态多态](#场景二：trait object（特征对象）动态多态)
    • 场景三：栈上大对象
  • [Rc 使用场景](#Rc 使用场景)
  • • 场景一：树结构共享子节点
  • [Rc 使用场景](#Rc 使用场景)
  • • 场景一：多线程共享配置
    • 场景二：多线程共享可变状态
    • 场景三：异步场景的状态共享
  • 总结

Rust 的 Box、Rc、Arc 到底怎么选？

Box、Rc、Arc 虽同为堆内存管理工具，使用场景却截然不同，稍有不慎便会触发编译报错，甚至埋下运行时隐患。本文将给出清晰的决策路径，拆解典型应用场景，规避常见误区，让你写代码时能快速判断：何时用 Box、何时用 Rc、何时必须用 Arc。

三者解决的是不同问题

Box、Rc、Arc 本质都是堆内存管理工具，不存在谁更优，只存在谁更适配当前场景。我们将逐一拆解它们的定位。

Box：唯一所有权 + 堆分配

Box<T> 是 Rust 最基础的智能指针，核心作用是将栈上的 T 类型数据转移到堆上，栈上仅保留一个指向堆内存的指针。特点是：

• 单一所有权：同一时间仅一个变量拥有 Box 指向的堆内存，完全契合 Rust 所有权核心规则；
• 无引用计数：无需在运行时维护引用个数，因此零额外运行时开销；
• 自动释放：Box 离开作用域时，会自动释放堆上关联内存，无需手动管理。

那么何时用 Box 呢？如下所示：

1. 规避栈上大对象：若对象体积较大（如包含1000个元素的数组），直接存入栈会占用大量空间，甚至引发栈溢出，此时用 Box 将其转入堆，栈上仅留指针；
2. 定义递归类型：如链表、树结构，其节点需包含指向自身的字段，直接定义会触发无限递归的编译错误，用 Box 可完美解决。
3. 实现特征对象：需要使用动态多态的场景时，必须用 Box<dyn Trait>，因为 trait 是动态大小类型，无法直接存于栈上。

Rc：单线程共享所有权

Rc<T>（Reference Counting，引用计数）的核心是允许多个变量共享同一块堆内存，通过运行时维护引用计数器，跟踪引用该内存的变量个数，当计数器为0时自动释放内存。特点是：

• 多个所有权：同一时间可多个变量拥有 Rc 指向的堆内存，所有所有者共享该内存；
• 非线程安全：引用计数操作非原子操作，因此不可跨线程使用；
• 轻量开销：引用计数操作简单，性能开销低于 Arc，但高于 Box，毕竟需要额外维护计数器。

那么何时用 Rc 呢？如下所示：

1. 树/图结构共享：如二叉树的多个父节点需共享同一个子节点，用 Rc 可避免数据重复复制，提升效率；
2. 单线程状态共享：如单线程 GUI 应用（如 egui）中，多个组件需访问同一状态，用 Rc 即可安全实现；
3. 规避所有权转移麻烦：无需跨线程，且不想因所有权转移导致变量无法使用时，Rc 是最优选择。

Arc：多线程共享所有权

Arc<T>（Atomic Reference Counting，原子引用计数）是 Rc 的线程安全版本，核心逻辑与 Rc 一致，但引用计数操作采用原子操作，可确保多线程环境下的安全性。特点是：

• 多个所有权：与 Rc 一致，支持多个变量共享同一块堆内存；
• 线程安全：引用计数增减为原子操作，因此可跨线程使用；
• 开销较高：原子操作比普通引用计数更耗时，且会产生缓存行竞争（cache line contention），性能开销高于 Rc。

那么何时用 Arc 呢？如下所示：

1. 多线程共享配置：如 Web 服务中，多个线程需共享同一配置对象，用 Arc 可实现安全共享；
2. 并发数据共享：如多线程处理任务时，需共享计数器、队列等数据，需配合 Mutex/RwLock 使用；
3. 异步场景：在 Tokio 等异步运行时中，任务可能在不同线程间切换，共享状态必须用 Arc 保证线程安全。

一表讲清三者关系

为方便快速查阅对比，我们用一个表格进行对比，一目了然：

类型	所有权	线程安全	性能开销	使用场景
Box<T>	单一	✅（本身无线程安全问题，取决于内部数据）	最低（零额外开销）	堆分配、递归类型、trait object
Rc<T>	多个	❌（不可跨线程）	中（轻量引用计数）	单线程共享、树/图结构、单线程状态
Arc<T>	多个	✅（原子引用计数，可跨线程）	较高（原子操作开销）	多线程共享、并发场景、async 状态

Box 使用场景

场景一：递归类型（链表/树）

实现简单单向链表时，节点需包含下一个节点，而 Rust 编译时需明确类型大小，下面的定义会触发"无限递归"报错：

enum List {
    Cons(i32, List),
    Nil,
}

正确的做法是用 Box 包裹，如下所示：

// 用 Box 实现递归链表
enum List {
    Cons(i32, Box<List>),
    Nil,
}

fn main() {
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
}

场景二：trait object（特征对象）动态多态

需用统一类型接收不同实现时，必须用 Box<dyn Trait>。例如定义形状 trait，让圆形、矩形实现该 trait，用 Vec 存储不同形状：

trait Shape {
    fn area(&self) -> f64;
}

struct Circle(f64);
impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.0 * self.0
    }
}

struct Rectangle(f64, f64);
impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.0 * self.1
    }
}

fn main() {
    // 用 Box<dyn Shape> 实现动态多态
    let shapes: Vec<Box<dyn Shape>> = vec![Box::new(Circle(5.0)), Box::new(Rectangle(3.0, 4.0))];
    for shape in shapes {
        println!("面积: {}", shape.area());
    }
}

场景三：栈上大对象

若对象体积较大（如包含10000个整数的数组），直接存入栈会占用大量空间，进而导致栈溢出，而用 Box 将其转入堆即可规避栈溢出：

// 大对象放入堆中，避免栈溢出
let big_array: Box<[i32; 10000]> = Box::new([0; 10000]);

Rc 使用场景

场景一：树结构共享子节点

二叉树中，多个父节点可能共享同一个子节点，比如一个子树被多个节点引用，用 Rc 可避免子节点重复复制，提升效率：

use std::rc::Rc;

struct Node {
    value: i32,
    left: Option<Rc<Node>>,
    right: Option<Rc<Node>>,
}

fn main() {
    // 共享的子节点
    let shared_child = Rc::new(Node {
        value: 5,
        left: None,
        right: None,
    });

    // 两个父节点共享同一个子节点
    let parent1 = Node {
        value: 10,
        left: Some(Rc::clone(&shared_child)),
        right: None,
    };

    let parent2 = Node {
        value: 20,
        left: Some(Rc::clone(&shared_child)),
        right: None,
    };
}

Rc 使用场景

场景一：多线程共享配置

在多线程的场景下，可以使用 Arc 可实现安全共享数据，比如多个线程共享配置：

use std::sync::Arc;
use std::thread;

#[derive(Debug)]
struct Config {
    port: u16,
    db_url: String,
}

fn main() {
    let config = Arc::new(Config {
        port: 8080,
        db_url: "mysql://localhost:3306/test".to_string(),
    });

    // 多个线程共享配置
    for i in 0..3 {
        let config_clone = Arc::clone(&config);
        thread::spawn(move || {
            println!(
                "线程 {}: 端口={}, 数据库地址={}",
                i, config_clone.port, config_clone.db_url
            );
        });
    }

    thread::sleep(std::time::Duration::from_secs(1));
}

场景二：多线程共享可变状态

若需共享可变数据，Arc 必须配合 Mutex（互斥锁）或 RwLock（读写锁）使用，确保多线程下的数据安全：

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Arc + Mutex 实现多线程可变共享
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("计数器结果: {}", counter.lock().unwrap()); // 输出：10
}

场景三：异步场景的状态共享

在异步编程时，任务可能在不同线程间切换，共享状态必须用 Arc 保证线程安全，例如共享数据库连接池：

use std::sync::Arc;
use tokio::join;

// 简化的数据库连接池
struct DbPool;

async fn task(pool: Arc<DbPool>) {
    println!("使用连接池处理任务");
}

#[tokio::main]
async fn main() {
    let pool = Arc::new(DbPool);

    let task1 = task(Arc::clone(&pool));
    let task2 = task(Arc::clone(&pool));

    join!(task1, task2);
}

总结

一句话总结：优先用 Box，仅当明确需要共享所有权时，再根据是否跨线程选择 Rc 或 Arc；使用 Arc 时，需配合 Mutex/RwLock 保证内部数据安全。