从零手写智能指针 MyRc:AI 拆解引用计数与 Drop 析构深坑

在 Rust 标准库中,Rc<T>(Reference Counted)是我们用来在单线程环境下实现**“多所有权(Multiple Ownership)共享同一块堆内存数据”**的最常用智能指针。
平时我们调用 Rc::clone(&ptr) 时,底层的引用计数是如何自增的?当各个变量离开作用域被析构时,Rc 是如何确保“只有在最后一个引用被销毁时才真正释放堆内存”的?如果内部包裹的数据拥有自定义的 Drop 逻辑,智能指针该如何保证既析构内部数据(drop_in_place),又正确释放外部分配的堆内存块(dealloc)?
为了彻底搞懂智能指针的物理内存布局与 RAII 析构深坑,昨晚我让大模型带领我抛弃标准库,从零手写一个真正可用的强类型智能指针 MyRc<T>!
今天这篇文章,我们剖析 MyRc<T> 的完整实现与 NonNull 内存管理心法。
1. MyRc<T> 的底层物理内存布局
一个 Rc 智能指针本身在栈上仅仅占用一个裸指针的大小(8 字节)。它指向堆上的一块复合数据结构 RcBox<T>:
[ 栈上的 MyRc<T> 实例 A (8 字节指针) ] ──┐
│
[ 栈上的 MyRc<T> 实例 B (8 字节指针) ] ──┼─► 指向堆内存 ──► ┌───────────────────────────┐
│ │ RcBox<T> (堆分配内存) │
[ 栈上的 MyRc<T> 实例 C (8 字节指针) ] ──┘ │ ├── strong: Cell<usize> = 3│
│ └── value: T (真实用户数据) │
└───────────────────────────┘
strong(强引用计数):记录当前存活的MyRc实例数量;value:存储真实泛型数据T;Cell<usize>:提供单线程内部可变性,使得在共享不可变引用的前提下能够原地递增/递减计数器。
2. 从零手写 MyRc<T> 完整实现
在 crates/packet-core/src/my_rc.rs 中:
// crates/packet-core/src/my_rc.rs
use std::cell::Cell;
use std::ops::Deref;
use std::ptr::NonNull;
/// 堆上实际分配的包装结构体
struct RcBox<T> {
strong: Cell<usize>,
value: T,
}
pub struct MyRc<T> {
// 使用 NonNull<T> 表达非空、协变的原始指针
ptr: NonNull<RcBox<T>>,
}
impl<T> MyRc<T> {
/// 创建一个新的 MyRc 实例,在堆上分配 RcBox
pub fn new(value: T) -> Self {
let boxed = Box::new(RcBox {
strong: Cell::new(1), // 初始强引用计数为 1
value,
});
// Box::into_raw 放弃 Box 的自动析构权,将其转换为堆裸指针
let raw_ptr = Box::into_raw(boxed);
let ptr = unsafe { NonNull::new_unchecked(raw_ptr) };
Self { ptr }
}
/// 获取当前的强引用计数
pub fn strong_count(&self) -> usize {
unsafe { self.ptr.as_ref().strong.get() }
}
}
// 1. 实现 Clone:仅增加引用计数,零堆数据拷贝!
impl<T> Clone for MyRc<T> {
fn clone(&self) -> Self {
unsafe {
let rc_box = self.ptr.as_ref();
let count = rc_box.strong.get();
rc_box.strong.set(count + 1); // 引用计数 +1
}
Self { ptr: self.ptr }
}
}
// 2. 实现 Deref:支持透明解引用访问内部 T 的方法
impl<T> Deref for MyRc<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
unsafe { &self.ptr.as_ref().value }
}
}
// 3. 核心大坑:实现 Drop 析构!
impl<T> Drop for MyRc<T> {
fn drop(&mut self) {
unsafe {
let rc_box = self.ptr.as_ref();
let count = rc_box.strong.get();
if count > 1 {
// 还有其他引用存活,仅仅将计数器 -1
rc_box.strong.set(count - 1);
} else {
// 引用计数归零!当前是最后一个存活的持有者!
// 将裸指针重新组装回 Box,利用 Box 的 Drop 同时析构 value 与释放堆内存!
let _ = Box::from_raw(self.ptr.as_ptr());
println!("RcBox 强引用归零,堆内存已成功安全释放!");
}
}
}
}
3. 单元测试验证:验证析构时机与共享读取
#[cfg(test)]
mod tests {
use super::*;
struct CustomResource {
name: String,
}
impl Drop for CustomResource {
fn drop(&mut self) {
println!(" 自定义资源 '{}' 正在执行 Drop 析构!", self.name);
}
}
#[test]
fn test_my_rc_lifecycle() {
let rc1 = MyRc::new(CustomResource { name: "TCP-Session-Pool".to_string() });
assert_eq!(rc1.strong_count(), 1);
assert_eq!(rc1.name, "TCP-Session-Pool"); // 测试 Deref
{
let rc2 = rc1.clone();
assert_eq!(rc1.strong_count(), 2);
assert_eq!(rc2.strong_count(), 2);
let rc3 = rc2.clone();
assert_eq!(rc1.strong_count(), 3);
println!("作用域内部引用计数: {}", rc3.strong_count());
} // rc2, rc3 在此离开作用域并 Drop!
assert_eq!(rc1.strong_count(), 1);
println!("外部作用域剩余计数: {}", rc1.strong_count());
} // rc1 在此离开作用域,触发最终的 Box::from_raw 与 CustomResource 析构!
}
测试运行输出:
作用域内部引用计数: 3
外部作用域剩余计数: 1
RcBox 强引用归零,堆内存已成功安全释放!
自定义资源 'TCP-Session-Pool' 正在执行 Drop 析构!
4. 手写智能指针必须小心的三大深坑
- 悬垂野指针(Use-After-Free):在
Clone时若忘记+1,某个实例提前 Drop 会导致其他持有者访问已被释放的堆内存; - 内存泄漏(Leakage):若在计数归零时忘记调用
Box::from_raw,堆内存将永久滞留; NonNull<T>的协变性(Covariance):标准库选择NonNull<T>而不是*mut T,是因为NonNull在类型系统上对T保持协变,能更好地与生命周期子类型化协同工作。
总结
手写 MyRc 的深刻收获:
- 彻底揭开了智能指针的黑盒——它只是裸指针、内部可变性与 RAII Drop 契约的完美封装;
- 搞懂了利用
Box::into_raw与Box::from_raw进行堆内存所有权交接的标准范式; - 为理解更复杂的跨线程无锁并发智能指针
Arc扫清了所有理论障碍。
1318



被折叠的 条评论
为什么被折叠?



