Rc:共享所有权

所有权的"唯一所有者"撞墙了

到目前为止, 所有权规则要求每份数据有且只有一个所有者. 这在大多数时候很好, 但有些数据结构天然需要"被多个地方共同拥有". 最经典的例子是图或共享列表:

// 设想: 两个列表 b 和 c 都想以 a 为尾部(共享同一段数据)
//   b → 3 ┐
//          ├→ a(5 → 10 → Nil)
//   c → 4 ┘

用 Box 做不到--因为 Box 是唯一所有权, a 一旦被移进 b, 就不能再移进 c:

let a = Box::new(/* ... */);
let b = Cons(3, a);  // a 的所有权移入 b
let c = Cons(4, a);  // 错误! a 已经被移走了

这里"谁该是 a 的唯一所有者"根本没有答案--b 和 c 都需要它. 所有权模型在这类共享结构面前, 需要一个"放宽限制"的工具.

Rc: 引用计数的共享所有权

Rc<T> 让多个所有者共享数据. "克隆"一个 Rc 不复制底层数据, 只是增加引用计数并得到一个新的指向同一数据的指针:

use std::rc::Rc;

let a = Rc::new(String::from("shared"));   // 计数 = 1
let b = Rc::clone(&a);                     // 计数 = 2, b 和 a 指向同一数据
let c = Rc::clone(&a);                     // 计数 = 3

println!("计数: {}", Rc::strong_count(&a)); // 3
// a, b, c 共享同一个 String, 没有发生数据复制

数据在引用计数归零时才被释放. 只要还有任何一个 Rc 活着, 数据就不会被清理--这正好满足"多个所有者"的需求.

关键限制: 共享的数据不可变

这是 Rc 最重要的约束, 也直接呼应借用规则. 既然多个 Rc 同时持有数据(等于多个共享引用同时存在), 根据"共享不可变"--Rc 只给不可变访问:

let a = Rc::new(String::from("hi"));
let b = Rc::clone(&a);
// a.push_str("!"); // 错误! 不能通过 Rc 修改数据
println!("{a} {b}"); // 只能读

第二个限制: 仅限单线程

Rc 的引用计数增减不是原子操作, 多线程同时改计数会产生数据竞争. 因此 Rc 被设计为不能跨线程(它没实现 Send/Sync, 第 09 篇详谈). 多线程下的共享所有权要用它的线程安全版本 Arc(Atomic Rc, 第 10 篇):

快速回顾

• 解决的问题: 突破"唯一所有者"限制, 让多个变量共同拥有同一份数据(如共享列表, 图).
• 机制: 引用计数, Rc::clone 加一, 销毁减一, 归零才释放; clone 极廉价, 非深拷贝.
• 限制一: 共享数据默认不可变(遵守"共享不可变"); 要可变需配 RefCell(下一篇).
• 限制二: 计数非原子, 仅限单线程; 跨线程用 Arc.
• 设计思想: Rc/Arc 分立体现"不为不用的安全付费"--单线程零开销, 跨线程才付原子成本.

动手练习

1. 下面代码为什么编译不过? 用 Rc 修复, 使 b, c 能共享 a.

   let a = Box::new(5); let b = vec![a]; let c = vec![a];

use std::rc::Rc;
let a = Rc::new(5);
let b = vec![Rc::clone(&a)];
let c = vec![Rc::clone(&a)]; // OK, 计数变为 3

2. 预测这段代码各处的引用计数.

   use std::rc::Rc; let a = Rc::new(1); // (A) let b = Rc::clone(&a); // (B) { let c = Rc::clone(&a); // (C) println!("{}", Rc::strong_count(&a)); // 此处? } // (D) println!("{}", Rc::strong_count(&a)); // 此处?

3. 为什么下面会报错? 这反映了 Rc 的什么限制?

   use std::rc::Rc; let a = Rc::new(String::from("hi")); a.push_str("!");

4. 什么时候该用 Rc, 什么时候该用 Arc? 为什么不统一用 Arc?