Rc<T> 引用计数
什么是 Rc<T>
Rust 的所有权规则规定:每个值在同一时刻只能有一个所有者。但在实际编程中,有些数据结构天然就需要被多个部分共同拥有。比如一张图中,多条边可能指向同一个节点;一棵树中,父节点和多个子节点之间可能需要共享某些数据。
Rc<T> 就是为了解决"共享所有权"问题而设计的。Rc 是 Reference Counting(引用计数)的缩写。它内部维护一个计数器,记录当前有多少个 Rc 指向同一份数据。每次 Rc::clone 时计数加一,每次一个 Rc 被 drop 时计数减一。当计数降到零时,数据才会被真正释放。
Rc<T> 只能用于单线程场景。如果需要跨线程共享数据,要用 Arc<T>(原子引用计数)。
Rc 的工作原理
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() 的区别
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 最经典的使用场景。两个链表共享同一个尾部。
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 在第一次使用时就转移了所有权。
图结构中的共享节点
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 "多个不可变引用 或 一个可变引用"的借用规则。
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 配合:共享可变数据
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 的常用方法
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 实现一个简单的事件订阅系统。
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>。