`Pin<Ptr>` 与 `Drop` 的深层博弈:Comprehensive Rust 中 `!Unpin` 类型的析构安全实践
Pin<Ptr> 与 Drop 的深层博弈:Comprehensive Rust 中 !Unpin 类型的析构安全实践
在 Rust 的内存安全体系中,Pin 与 Drop 的组合是 unsafe 深潜(Unsafe Deep Dive)章节中最微妙的一环:pinned 值一旦固定(pinned),其内存地址在析构前都不得移动,而 Drop::drop 接收的却是 &mut self——一个理论上"允许移动"的接口。本文以 Google Android 团队 Rust 课程(Comprehensive Rust)中 pin-and-drop.md 为骨架,剖析 !Unpin 类型实现 Drop 时容易踩中的双重释放(double free)陷阱,并给出基于 Pin<&mut T> 辅助函数的安全实现模式。读完你将掌握:为什么 drop 内部移动值是 UB(未定义行为)、ptr::read / mem::replace 如何悄悄破坏 pinning 保证,以及如何借助 PhantomPinned 与 Pin::new_unchecked 写出既正确又可维护的析构逻辑。
问题本质:Drop 的签名与 pinning 保证的冲突
Drop trait 的签名是:
pub trait Drop {
fn drop(&mut self);
}
&mut self 意味着在 drop 方法体内,你拥有对值的可变访问权,这允许将值移动出去。然而,对于被 pinned 的 !Unpin 类型,值一旦被固定就绝对不允许移动(见 what-pinning-is.md 中对"pinned type cannot change its memory address"的定义)。这两者之间存在天然冲突:编译器不会因为你实现了 Drop 就自动阻止你在方法体内移动字段——drop 内部的一切操作都由 unsafe 代码自行负责。
更关键的是,drop 是值生命周期中最后一次被使用的地方。Rust 的析构语义是:drop 方法执行完毕后,值的字段会再次被自动析构。任何在 drop 内部"复制出一份、然后又让原字段继续存活"的操作,最终都会导致同一块内存被释放两次——即双重释放。
错误示范:ptr::read 引发的双重释放
课程文档 pin-and-drop.md 首先给出一个典型的错误实现。一个自引用类型 SelfRef 持有一个 *const String 指向自己的 data 字段,并实现 Drop:
struct SelfRef {
data: String,
ptr: *const String,
}
impl Drop for SelfRef {
fn drop(&mut self) {
// BAD: `ptr::read` moves `self.data` out of `self`.
// When `_dupe` is dropped at the end of the function, it's a double free!
let _dupe = unsafe { std::ptr::read(&self.data) };
}
}
这里 std::ptr::read(&self.data) 会对 data 做一次逐位复制(bitwise copy),把它"搬"进局部变量 _dupe。注意 ptr::read 与赋值、mem::replace 一样,属于可以让值"移动或复制"的操作。这类操作会带来两个问题:
- 破坏 pinning 保证:pinned 类型对内存稳定性作出承诺,
ptr::read这类操作在类型系统不知情的情况下复制/移动数据,导致内部指针(如SelfRef::ptr)失效(详见 definition-of-pin.md 中关于Pin保证的说明)。 - 双重释放(double free):
_dupe是self.data的逐位副本,在方法结束时,_dupe与self(及其中的data)都会被析构。同一份String的堆缓冲被释放两次,这是未定义行为。
课程在此处的教学要点是:!Unpin 类型安全地实现 Drop 很难,实现者必须保证不移动 pinned 值。
正确范式:辅助函数 + Pin::new_unchecked
正确的做法是:把"析构时要执行的逻辑"抽取到一个接收 Pin<&mut T> 的辅助函数中,让编译器与调用方都明确"该值被固定、不可移动";在 Drop::drop 内部再通过 unsafe 的 Pin::new_unchecked 构造 Pin 引用,因为此时已是值的最后一次使用。
课程给出的完整正确示例(含 PhantomPinned 自引用构造):
use std::marker::PhantomPinned;
use std::pin::Pin;
struct SelfRef {
data: String,
ptr: *const String,
_pin: PhantomPinned,
}
impl SelfRef {
fn new(data: impl Into<String>) -> Pin<Box<SelfRef>> {
let mut this = Box::pin(SelfRef {
data: data.into(),
ptr: std::ptr::null(),
_pin: PhantomPinned,
});
let ptr: *const String = &this.data;
// SAFETY: `this` is pinned before we create the self-reference.
unsafe {
Pin::as_mut(&mut this).get_unchecked_mut().ptr = ptr;
}
this
}
// This function can only be called on a pinned `SelfRef`.
unsafe fn drop_pinned(self: Pin<&mut SelfRef>) {
// `self` is pinned, so we must not move out of it.
println!("dropping {}", self.data);
}
}
impl Drop for SelfRef {
fn drop(&mut self) {
// We can safely call `drop_pinned` because `drop` is the last time
// the value is used. We use `new_unchecked` because we know `self`
// will not be moved again.
unsafe {
SelfRef::drop_pinned(Pin::new_unchecked(self));
}
}
}
fn main() {
let _pinned = SelfRef::new("Hello, ");
} // `Drop` runs without moving the pinned value
拆解这段代码的四个关键点:
_pin: PhantomPinned字段:PhantomPinned是一个 marker 类型,其定义等价于impl !Unpin for PhantomPinned {}(见 phantompinned.md)。任何包含PhantomPinned字段的类型默认不实现Unpin,从而在被Pin包裹时强制启用 pinning 语义。- 构造期建立自引用:
SelfRef::new返回Pin<Box<SelfRef>>。先用Box::pin完成堆分配并固定,再通过Pin::as_mut(...).get_unchecked_mut()拿到可变引用写入ptr。这里的unsafe是合法的:固定发生在自引用建立之前,且之后不再移动。 drop_pinned(self: Pin<&mut SelfRef>):接收方法(receiver)是Pin<&mut SelfRef>的辅助函数,签名本身就声明了"值已固定、不可移动",从类型层面阻止误用。Pin::new_unchecked(self):在Drop::drop内把&mut self重新包成Pin<&mut SelfRef>。之所以安全,是因为drop是值被使用的最后时刻——方法返回后值即刻析构,不存在后续移动的可能,因此不会违反"固定后不得移动"的契约。这正是 definition-of-pin.md 所述Pin::new_unchecked的语义:它不执行任何运行时检查,安全性的全部责任落在调用者身上。
实战延伸:课后练习里的三个修复方案
在配套的练习文档 drop-and-not-unpin-worked-example.md 中,课程给出了一个更贴近真实的场景:在 Drop 里把字段数据搬进一个线程局部批量日志(thread_local! + RefCell<Vec<String>>),用于遥测或日志后处理。示例中同样用 std::ptr::read(&self.data) 移动字段,并标注了一条错误的安全注释("reading bytes from a String")——ptr::read 只是逐位复制,self.data 仍会在方法结束时被再次析构,造成双重释放。
该练习针对"如何在析构时消费字段"给出了三条修复路径,值得逐一掌握:
- 方案 0:重新设计(Redesign)——最彻底的做法是让后处理系统根本不依赖
Drop,从源头消除在析构期移动值的需求。 - 方案 1:Clone——最直观的选择:
let payload = self.data.0.clone();。代价是分配新内存(heap allocation),且要求字段类型实现Clone。 - 方案 2:
ManuallyDrop——把字段包装进std::mem::ManuallyDrop,用ManuallyDrop::take(&mut self.data)安全地"取出"所有权,同时阻止字段在方法结束时被第二次自动析构。这是不分配内存的零开销方案:
struct SelfRef {
data: ManuallyDrop<CustomString>,
ptr: *const CustomString,
_pin: PhantomPinned,
}
impl Drop for SelfRef {
fn drop(&mut self) {
// SAFETY: self.data
let payload = unsafe { ManuallyDrop::take(&mut self.data) };
BATCH_FOR_PROCESSING.with(|log| log.borrow_mut().push(payload.0));
}
}
这三种方案对应三种工程权衡:重构业务流、接受分配、或借用 ManuallyDrop 精确控制析构时机。它们与本文的 drop_pinned 辅助函数模式并不互斥——前者解决"如何消费字段",后者解决"如何在类型层面约束不可移动"。
底层机制:Pin、Unpin 与自引用类型的全景
为了真正理解上面代码为何这样写,需要把 pinning 的知识链串起来(全部来自本仓库 pinning 章节,入口见 README.md):
Unpin是 auto trait:绝大多数类型自动实现Unpin,表示"我没有自引用,移动我永远安全"。!Unpin的类型一旦被 pinned 就绝不允许移动,典型包括编译器生成的 future、含PhantomPinned字段的类型,以及部分包装 C++ 对象的类型(见 unpin-trait.md)。Pin<Ptr>是标准库类型而非语言特性:它只包一层指针类型(任何Deref目标),Pin::new仅接受Deref<Target: Unpin>的指针,!Unpin目标只能走 unsafe 的Pin::new_unchecked。这个检查是零成本的编译期约束,new与new_unchecked之间没有运行时差异(见 definition-of-pin.md)。- 为什么自引用类型需要 pinning:以 self-referential-buffer.md 的
SelfReferentialBuffer { data: [u8; 1024], cursor: *mut u8 }为例,cursor指向data内部;一旦实例发生移动,cursor的地址就失效。课程先展示了"每次移动后手动调用update_cursor()"的原始指针方案(rust-raw-pointers.md,其unsafe块缺乏安全注释、范围过大、不可判定为 sound),再展示用PhantomPinned+Pin<Box<Self>>的固定方案(rust-pin.md,其::new()返回Pin<Box<Self>>而非Self,因为Pin必须配合Box这类指针类型,这带来一次堆分配)。 Pin设计的历史包袱:Pin<Ptr>最初主要服务于 async runtime 的开发者(约百人规模),Rust 团队选择了对编译器更简单、但对使用者更不 ergonomic 的设计(见 why-difficult.md)。理解这一点有助于接受PinAPI 的别扭感。
把这些串起来就不难看出:pin-and-drop 文档中的正确实现,正是"PhantomPinned 制造 !Unpin → 构造期固定并建立自引用 → drop_pinned 用接收者签名固化约束 → Drop::drop 内以 new_unchecked 收尾"这一完整链条的收束点。
实践清单:为 !Unpin 类型实现 Drop 的检查要点
综合本文档与配套练习,在为 pinned、!Unpin 类型编写 Drop 时,建议逐条核对:
- 警惕一切可移动/复制的操作:赋值(
=)、std::ptr::read、mem::replace、mem::take都可能悄然破坏 pinning 保证,让内部指针失效且类型系统毫无感知。使用前先问:它会让字段脱离原位吗? - 优先抽取
Pin<&mut T>辅助函数:把析构逻辑放在unsafe fn drop_pinned(self: Pin<&mut Self>)里,让"不可移动"成为签名的一部分,而不是靠注释提醒。 Pin::new_unchecked的安全前提:只能在值的最后一次使用(即drop内部)使用它重新包装&mut self;在drop返回后值即被析构,不存在再次移动的机会。- 消费字段的三种路径:重新设计避免在析构期取数据、
Clone(接受分配)、或ManuallyDrop::take(零分配、需把字段声明为ManuallyDrop<T>)。 - 为每个
unsafe写准确的安全注释:注意,仅仅写"SAFETY: ..."并不代表安全——课程练习特意展示了错误的安全注释,真正的安全取决于注释描述的前提是否真实成立(例如ptr::read留下的字段仍会被二次析构这一事实)。
结语
Pin 与 Drop 的组合是 Rust 内存安全模型中"unsafe 的边界由你亲自守护"的典型场景:类型系统能保证"pinned 值不会被安全代码移动",却无法阻止你在 drop 内部用 ptr::read 自我破坏。Comprehensive Rust 的这一节给出了清晰的两步解法——用 PhantomPinned 明确 !Unpin 身份,用 Pin<&mut T> 辅助函数 + Pin::new_unchecked 把析构逻辑约束在"最后时刻、不可移动"的安全轨道上。配合 drop-and-not-unpin-worked-example.md 的练习(Redesign / Clone / ManuallyDrop 三方案)以及 self-referential-buffer.md 的原始指针对照,你可以从"会写 Pin"进阶到"理解 Pin 为什么存在、何时必须 unsafe、以及如何把 unsafe 的边界收敛到最小"。