Rc<T> 引用计数 ​

什么是 Rc<T> ​

Rust 的所有权规则规定:每个值在同一时刻只能有一个所有者。但在实际编程中,有些数据结构天然就需要被多个部分共同拥有。比如一张图中,多条边可能指向同一个节点;一棵树中,父节点和多个子节点之间可能需要共享某些数据。

Rc<T> 就是为了解决"共享所有权"问题而设计的。Rc 是 Reference Counting(引用计数)的缩写。它内部维护一个计数器,记录当前有多少个 Rc 指向同一份数据。每次 Rc::clone 时计数加一,每次一个 Rc 被 drop 时计数减一。当计数降到零时,数据才会被真正释放。

Rc<T> 只能用于单线程场景。如果需要跨线程共享数据,要用 Arc<T>(原子引用计数)。

Rc 的工作原理 ​

rust
use std::rc::Rc;

fn main() {
    // 创建一个 Rc,引用计数初始为 1
    let a = Rc::new(String::from("共享数据"));
    println!("创建 a 后,引用计数: {}", Rc::strong_count(&a)); // 1

    {
        // Rc::clone 不会深拷贝数据,只是增加引用计数
        let b = Rc::clone(&a);
        println!("创建 b 后,引用计数: {}", Rc::strong_count(&a)); // 2

        // b 和 a 指向同一份数据
        println!("a = {}, b = {}", a, b);
        println!("a 和 b 指向同一块内存: {}", Rc::ptr_eq(&a, &b)); // true

        // 再 clone 一次
        let c = Rc::clone(&a);
        println!("创建 c 后,引用计数: {}", Rc::strong_count(&a)); // 3

    } // b 和 c 在这里离开作用域,引用计数减到 1

    println!("b 和 c 离开作用域后,引用计数: {}", Rc::strong_count(&a)); // 1

    // 这里 a 仍然有效,数据没有被释放
    println!("a 仍然可用: {}", a);

} // a 离开作用域,引用计数降到 0,数据被释放

Rc::clone 和普通的 .clone() 不同:它不会复制底层数据,只是增加引用计数,开销很小(一次整数加法)。这也是为什么 Rust 社区推荐写 Rc::clone(&a) 而不是 a.clone()——前者明确表达了"只是增加引用计数"的意图,避免和深拷贝混淆。

Rc::clone vs .clone() 的区别 ​

rust
use std::rc::Rc;

fn main() {
    let original = Rc::new(vec![1, 2, 3, 4, 5]);

    // Rc::clone 只增加引用计数,不复制 Vec 数据
    // 开销:一次原子计数器加一
    let shared = Rc::clone(&original);

    // 两个 Rc 指向同一个 Vec
    println!("指向同一份数据: {}", Rc::ptr_eq(&original, &shared)); // true

    // 如果你对 Rc 里面的值调用 .clone(),会深拷贝里面的数据
    // 注意:这需要先解引用到内部的 Vec,然后 clone Vec
    let deep_copy: Vec<i32> = (*original).clone();

    // deep_copy 是一个全新的 Vec,和 original 里的数据没有关系
    println!("original: {:?}", original);
    println!("deep_copy: {:?}", deep_copy);
}

用 Rc 解决多所有者问题 ​

共享链表 ​

这是 Rc 最经典的使用场景。两个链表共享同一个尾部。

rust
use std::rc::Rc;

// 用 Rc 替代 Box,允许多个链表共享同一个尾部
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use List::{Cons, Nil};

fn main() {
    // 创建共享的链表尾部: 5 -> 10 -> Nil
    let shared_tail = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("shared_tail 引用计数: {}", Rc::strong_count(&shared_tail)); // 1

    // 链表 b: 3 -> shared_tail (3 -> 5 -> 10 -> Nil)
    let b = Cons(3, Rc::clone(&shared_tail));
    println!("创建 b 后,shared_tail 引用计数: {}", Rc::strong_count(&shared_tail)); // 2

    // 链表 c: 4 -> shared_tail (4 -> 5 -> 10 -> Nil)
    let c = Cons(4, Rc::clone(&shared_tail));
    println!("创建 c 后,shared_tail 引用计数: {}", Rc::strong_count(&shared_tail)); // 3

    // b 和 c 都共享 shared_tail 指向的数据
    // 当 b、c、shared_tail 都离开作用域后,数据才会被释放
}

如果用 Box 而不是 Rc,第二个链表就无法共享尾部,因为 Box 在第一次使用时就转移了所有权。

图结构中的共享节点 ​

rust
use std::rc::Rc;

// 图中的节点
struct Node {
    id: u32,
    label: String,
}

// 图中的边,两个端点都是共享的引用
struct Edge {
    from: Rc<Node>,
    to: Rc<Node>,
    weight: f64,
}

fn main() {
    // 创建节点(每个节点可能被多条边引用)
    let node_a = Rc::new(Node { id: 1, label: String::from("A") });
    let node_b = Rc::new(Node { id: 2, label: String::from("B") });
    let node_c = Rc::new(Node { id: 3, label: String::from("C") });

    // 创建边(共享节点的所有权)
    let edges = vec![
        Edge {
            from: Rc::clone(&node_a),
            to: Rc::clone(&node_b),
            weight: 1.0,
        },
        Edge {
            from: Rc::clone(&node_b),
            to: Rc::clone(&node_c),
            weight: 2.0,
        },
        Edge {
            from: Rc::clone(&node_a),
            to: Rc::clone(&node_c),
            weight: 3.0,
        },
    ];

    // node_a 被 3 个 Rc 拥有(原始的 + 两条边)
    println!("node_a 引用计数: {}", Rc::strong_count(&node_a)); // 3
    // node_b 被 3 个 Rc 拥有
    println!("node_b 引用计数: {}", Rc::strong_count(&node_b)); // 3
    // node_c 被 3 个 Rc 拥有
    println!("node_c 引用计数: {}", Rc::strong_count(&node_c)); // 3

    for edge in &edges {
        println!(
            "{} --({})-> {}",
            edge.from.label, edge.weight, edge.to.label
        );
    }
}

Rc 只提供不可变访问 ​

Rc<T> 只允许通过不可变引用(&T)访问内部数据,不能直接修改。这是因为 Rc 的多个克隆可能同时被使用,如果允许其中一个修改数据,就会违反 Rust "多个不可变引用 或 一个可变引用"的借用规则。

rust
use std::rc::Rc;

fn main() {
    let data = Rc::new(vec![1, 2, 3]);

    // 可以读取
    println!("第一个元素: {}", data[0]);

    // 不能修改!编译错误
    // data.push(4); // 错误:cannot borrow as mutable

    // 如果确实需要修改 Rc 内部的数据,需要配合 RefCell 使用
    // 这就是 Rc<RefCell<T>> 模式(详见 RefCell 章节)
}

Rc 与 RefCell 配合:共享可变数据 ​

rust
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    // Rc<RefCell<T>> 是单线程下"共享可变数据"的标准模式
    // Rc 提供共享所有权,RefCell 提供内部可变性
    let shared_list = Rc::new(RefCell::new(vec![1, 2, 3]));

    // 创建多个共享引用
    let owner1 = Rc::clone(&shared_list);
    let owner2 = Rc::clone(&shared_list);

    // owner1 通过 RefCell 修改数据
    owner1.borrow_mut().push(4);

    // owner2 也可以修改数据
    owner2.borrow_mut().push(5);

    // 所有 owner 看到的都是修改后的数据
    println!("shared_list: {:?}", shared_list.borrow()); // [1, 2, 3, 4, 5]
    println!("owner1: {:?}", owner1.borrow());           // [1, 2, 3, 4, 5]
    println!("owner2: {:?}", owner2.borrow());           // [1, 2, 3, 4, 5]
}

Rc 的常用方法 ​

rust
use std::rc::Rc;

fn main() {
    let a = Rc::new(42);

    // strong_count: 获取强引用计数
    println!("强引用计数: {}", Rc::strong_count(&a)); // 1

    // weak_count: 获取弱引用计数(配合 Weak 使用)
    println!("弱引用计数: {}", Rc::weak_count(&a)); // 0

    let b = Rc::clone(&a);

    // ptr_eq: 判断两个 Rc 是否指向同一份数据
    println!("a 和 b 指向同一数据: {}", Rc::ptr_eq(&a, &b)); // true

    let c = Rc::new(42);
    println!("a 和 c 指向同一数据: {}", Rc::ptr_eq(&a, &c)); // false(虽然值相同,但是不同的分配)

    // try_unwrap: 如果引用计数为 1,取出内部值
    drop(b); // 先 drop b,让引用计数回到 1
    match Rc::try_unwrap(a) {
        Ok(value) => println!("成功取出值: {}", value),
        Err(rc) => println!("引用计数不为 1,无法取出。计数: {}", Rc::strong_count(&rc)),
    }
}

基本示例 ​

一个完整的例子:用 Rc 实现一个简单的事件订阅系统。

rust
use std::rc::Rc;
use std::cell::RefCell;

// 事件数据(被多个订阅者共享)
struct EventData {
    event_type: String,
    payload: String,
}

// 事件日志(多个组件共享同一份日志)
struct EventLog {
    entries: Vec<String>,
}

impl EventLog {
    fn new() -> Self {
        EventLog {
            entries: Vec::new(),
        }
    }

    fn add(&mut self, entry: String) {
        self.entries.push(entry);
    }

    fn print_all(&self) {
        println!("=== 事件日志 ===");
        for (i, entry) in self.entries.iter().enumerate() {
            println!("  [{}] {}", i + 1, entry);
        }
    }
}

// 组件 A:用户界面
struct UIComponent {
    // 通过 Rc<RefCell<>> 共享事件日志
    log: Rc<RefCell<EventLog>>,
    name: String,
}

impl UIComponent {
    fn handle_click(&self) {
        // 记录事件到共享日志
        let entry = format!("{}: 按钮被点击", self.name);
        self.log.borrow_mut().add(entry);
    }
}

// 组件 B:网络模块
struct NetworkComponent {
    log: Rc<RefCell<EventLog>>,
    name: String,
}

impl NetworkComponent {
    fn handle_response(&self, status: u16) {
        let entry = format!("{}: 收到响应 {}", self.name, status);
        self.log.borrow_mut().add(entry);
    }
}

fn main() {
    // 创建共享的事件日志
    let shared_log = Rc::new(RefCell::new(EventLog::new()));

    // 两个组件共享同一个日志
    let ui = UIComponent {
        log: Rc::clone(&shared_log),
        name: String::from("UI"),
    };

    let network = NetworkComponent {
        log: Rc::clone(&shared_log),
        name: String::from("Network"),
    };

    println!("日志引用计数: {}", Rc::strong_count(&shared_log)); // 3

    // 不同组件向同一个日志写入
    ui.handle_click();
    network.handle_response(200);
    ui.handle_click();
    network.handle_response(404);

    // 所有写入都汇聚到同一个日志对象中
    shared_log.borrow().print_all();
    // 输出:
    // === 事件日志 ===
    //   [1] UI: 按钮被点击
    //   [2] Network: 收到响应 200
    //   [3] UI: 按钮被点击
    //   [4] Network: 收到响应 404
}

常见问题 ​

问题一:Rc 为什么不能跨线程使用?

Rc 内部的引用计数器不是原子操作。如果两个线程同时对计数器加一或减一,就可能出现数据竞争。Rust 的类型系统通过不为 Rc<T> 实现 Send trait 来阻止你把 Rc 发送到其他线程。如果需要跨线程共享,用 Arc<T>。

问题二:Rc 会不会造成内存泄漏?

会。如果两个 Rc 互相引用形成循环(比如 A 持有 Rc 指向 B,B 也持有 Rc 指向 A),引用计数永远不会降到零,内存就泄漏了。解决方案是用 Weak<T>(弱引用)打破循环,弱引用不会增加强引用计数。

问题三:Rc::clone 和普通的 clone 有什么性能差异?

操作做了什么性能开销
Rc::clone(&rc)引用计数 +1极小(一次整数加法)
(*rc).clone()深拷贝内部数据取决于数据大小

问题四:Rc 和 Box 怎么选?

场景选择原因
数据只有一个所有者Box<T>更简单,开销更小
数据需要被多个部分共享Rc<T>提供共享所有权
需要跨线程共享Arc<T>Rc 不支持跨线程

适用场景 ​

  • 图数据结构:多条边共享同一个节点
  • 共享配置:程序中多个组件需要读取同一份配置数据
  • 缓存:缓存条目被多个地方引用,只在所有引用都消失后才清除
  • 观察者模式:多个观察者共享对同一个事件源的引用
  • 树结构中的共享子树:多个父节点共享同一个子树
  • Rc<RefCell<T>> 模式:单线程环境下需要共享可变数据的标准方案

注意事项 ​

  • Rc<T> 不能用于多线程,编译器会在你尝试跨线程传递时报错
  • Rc<T> 只提供不可变访问,如果需要修改内部数据,要配合 RefCell<T> 使用
  • 注意避免循环引用,循环引用会导致内存泄漏(引用计数永远不为零)
  • Rc::clone 的开销虽小,但在极端性能场景下(每秒数百万次),累积的计数操作也可能产生可观的开销
  • Rc<T> 在栈上占 8 个字节(一个指针),但堆上除了 T 的数据外,还额外存储了强引用计数和弱引用计数(两个 usize)
  • 推荐使用 Rc::clone(&a) 而非 a.clone() 来明确表达意图
  • Rc::try_unwrap 只在引用计数为 1 时才能成功取出内部值,否则返回 Err

总结 ​

Rc<T> 通过引用计数实现了单线程环境下的共享所有权。它的核心思想很简单:用一个计数器记录有多少个 Rc 指向同一份数据,计数归零时自动释放。Rc::clone 只增加计数器,不会深拷贝数据,所以开销很小。Rc<T> 最典型的使用场景是图、共享链表等需要多所有者的数据结构。因为 Rc 只提供不可变访问,如果需要修改共享数据,要配合 RefCell<T> 组成 Rc<RefCell<T>> 模式。使用 Rc 时要特别注意循环引用问题——两个 Rc 互相指向对方会导致内存泄漏,解决方案是用 Weak<T> 弱引用打破循环。Rc 不支持多线程,如果需要跨线程共享数据,应该使用 Arc<T>。