当前位置：首页 > news >正文

Rust 里最让人头疼的两个类型：Pin 和 Unpin，究竟解决了什么问题？

news 2026/4/26 0:00:30

本文基于 Cloudflare 工程师 Adam Chalmers 的技术博客，从一个实际编程场景出发，由浅入深地讲清楚 Rust 中 Pin、Unpin 与自引用类型的来龙去脉。

原文链接：https://blog.cloudflare.com/pin-and-unpin-in-rust/

一个看起来很简单的需求

假设你想写一个工具类型，能把任意异步函数包一层，额外记录它的执行耗时：

letasync_fn=reqwest::get("http://example.com");lettimed=TimedWrapper::new(async_fn);let(resp,duration)=timed.await;println!("耗时 {}ms，状态码 {}",duration.as_millis(),resp.unwrap().status());

接口设计挺优雅的。下面来实现它：

pubstructTimedWrapper<Fut:Future>{start:Option<Instant>,future:Fut,}

实现Futuretrait，在poll方法里调用内层 Future：

fnpoll(self:Pin<&mutSelf>,cx:&mutContext)->Poll<Self::Output>{letstart=self.start.get_or_insert_with(Instant::now);letinner_poll=self.future.poll(cx);// 编译报错！// ...}

编译器直接报错：Fut类型没有poll方法，只有Pin<&mut Fut>才有。

这个错误对初学者来说相当令人困惑——明明Fut实现了Future，为什么不能直接调用poll？Pin是什么？为什么它要出现在这里？

搞清楚这两个问题，是理解 Rust 异步编程的一道必经之坎。

先从 Future 说起

在 Rust 里，async fn本质上是一个返回Future的普通函数。Futuretrait 只有一个方法：poll。

调用poll，它会返回两种结果：Poll::Pending（还没好，待会再来）或者Poll::Ready(value)（完成了，结果在这里）。异步运行时（比如 Tokio）就是在不断地轮询各个 Future，谁 Ready 了就把结果给出去。

一个最简单的 Future 实现：

structRandFuture;implFutureforRandFuture{typeOutput=u16;fnpoll(self:Pin<&mutSelf>,_cx:&mutContext)->Poll<Self::Output>{Poll::Ready(rand::random())}}

注意poll方法的接收者不是&mut self，而是Pin<&mut Self>。这个细节正是问题的核心所在。

自引用类型：一个危险的结构

要理解Pin，必须先理解它要解决的问题：自引用类型（self-referential types）。

自引用类型，就是结构体内部的某个字段指向自身另一个字段的地址。设想有这样一个结构体：

struct MyStruct { val: i32, // 存储在内存地址 A pointer: *const i32, // 指向地址 A }

初始状态下一切正常，pointer指向val所在的内存地址，读取它能得到合法的值。

但是，如果这个结构体被移动了，会发生什么？

在 Rust 中，"移动"意味着把数据从一个内存位置搬到另一个位置。常见触发场景：把结构体传入函数、放进Box、或者Vec扩容重新分配内存……

移动之后，val搬到了新地址 B，但pointer字段里存的值还是老地址 A，而 A 处的内存已经不再属于这个结构体，随时可能被别的数据覆盖。

结果：悬垂指针。轻则程序崩溃，重则产生可被利用的安全漏洞。

偏偏 Future 经常是自引用的

为什么Future和自引用有关？

当你写下一个async函数，Rust 编译器会把它编译成一个状态机。这个状态机需要在各个await点之间保存局部变量。如果某个变量在await前被借用，借用的引用也需要被保存在状态机里——而这个状态机本身就包含了这个借用，于是形成了自引用。

这就是为什么Future::poll的接收者不能是普通的&mut self，而必须是Pin<&mut Self>——这是在要求调用方保证：调用 poll 之前，这个 Future 已经被"钉住"，不会再被移动。

Unpin：大多数类型的默认状态

在深入讲Pin之前，先讲Unpin。

Rust 把所有类型分成两类：

第一类：可以安全移动的类型。绝大多数类型都属于这一类，比如数字、字符串、布尔值，以及由这些类型组成的结构体和枚举。它们没有自引用，移动之后所有字段的值依然有效。这些类型自动实现Unpintrait（它是一个自动 trait，类似Send和Sync，不需要手动实现）。

第二类：不能安全移动的类型。也就是自引用类型，它们在 trait 系统里被标记为!Unpin（!表示"不实现"）。数量很少，但一旦被错误移动就会产生未定义行为。

Unpin这个名字乍看有点反直觉——它不是说"这个类型可以被 unpin"，而是说"这个类型根本不需要被 pin，随便移动都安全"。

Pin：给不能移动的类型上一把锁

Pin<P>是一个包装类型，它包裹一个指针P，并做出如下保证：如果 P 指向的类型是!Unpin，那么这个值在Pin存活期间不会被移动。

如果类型是Unpin，Pin就没什么限制效果，你随时可以取出值来移动。如果类型是!Unpin，Pin就是一把锁，取值只能通过 unsafe 代码，编译器用这种方式迫使你明确表态：“我知道这里有风险，我已经仔细审查过。”

简单来说：Pin不是锁住指针本身，而是锁住指针所指向的值，让它不能被移动。

Pin<&mut T>：给我一个对 T 的可变引用，但我保证在此期间不会移动 T。

这就是为什么Future::poll要求Pin<&mut Self>：执行器（executor）通过Pin向 Future 承诺，在调用poll的过程中，不会把这个 Future 移动到别的地方去。

回到原来的问题：怎么调用内层 Future 的 poll？

现在回头看TimedWrapper的问题。我们有一个Pin<&mut TimedWrapper<Fut>>，想要调用self.future.poll(cx)，也就是需要一个Pin<&mut Fut>。

从一个被 Pin 住的结构体中，访问其各个字段的过程，叫做projection（投影）。规则是这样的：

如果字段类型是Unpin，可以直接拿到&mut T（普通引用），随便用；
如果字段类型是!Unpin（比如内嵌的 Future），要拿到Pin<&mut T>，否则会破坏 Pin 的保证。

手动实现 projection 需要unsafe代码，且容易出错。好在有一个 crate 帮你做这件事。

pin-project：让 projection 变得安全又简洁

pin-project这个 crate 通过过程宏自动生成安全的 projection 代码。用法很直观：

#[pin_project::pin_project]pubstructTimedWrapper<Fut:Future>{start:Option<Instant>,#[pin]// 标记这个字段需要 Pin projectionfuture:Fut,}

加上#[pin_project]之后，它会自动生成一个project()方法。对标记了#[pin]的字段，project()返回Pin<&mut Fut>；对其余字段，返回普通的&mut T。

现在可以正确实现poll了：

fnpoll(self:Pin<&mutSelf>,cx:&mutContext)->Poll<Self::Output>{letmutthis=self.project();// 调用自动生成的 projectionletstart=this.start.get_or_insert_with(Instant::now);letinner_poll=this.future.as_mut().poll(cx);// 正确！letelapsed=start.elapsed();matchinner_poll{Poll::Pending=>Poll::Pending,Poll::Ready(output)=>Poll::Ready((output,elapsed)),}}