Pin/Unpin 核心概念
面试题
请解释 Rust 中 Pin 和 Unpin 的作用,为什么异步编程需要 Pin?
考察意图
Pin/Unpin 是 Rust 异步编程中最难理解的概念之一。面试官想看候选人能否解释自引用结构体的问题、Pin 如何防止值被移动,以及 Unpin 作为"可以安全移动"标记的含义。
答题要点
自引用结构体的问题
fn main() {
// 自引用结构体:结构体中有字段指向自身的另一个字段
// 如果结构体被移动(move),指针会指向旧的内存地址 → 悬垂指针
// 概念示例(伪代码,实际无法编译):
// struct SelfRef {
// data: String,
// ptr: *const String, // 指向 data 字段
// }
// 如果 SelfRef 被移动到新地址,ptr 仍指向旧地址 → 悬垂
// async 块生成的 Future 就是自引用结构体
// 因为 .await 跨越的引用会变成结构体内部的字段引用
// async {
// let data = String::from("hello");
// some_async_fn(&data).await; // data 的引用跨越了 await 点
// println!("{}", data);
// }
// 编译器生成的 Future 结构体大致为:
// struct MyFuture {
// data: String,
// ref_to_data: &String, // 指向上面的 data → 自引用
// }
println!("自引用结构体移动后内部指针会悬垂");
}Pin 的作用
use std::pin::Pin;
fn main() {
// Pin<P> 包装一个指针 P,保证被指向的值不会被移动
// Pin<&mut T> — 被钉住的可变引用
// Pin<Box<T>> — 被钉住的堆分配
// 对于实现了 Unpin 的类型,Pin 没有实际限制
// 因为这些类型移动是安全的
let mut x = 42;
let pinned = Pin::new(&mut x); // i32 是 Unpin 的,可以直接 Pin
println!("pinned: {}", pinned);
// 对于 !Unpin 的类型(如大多数 Future),
// Pin 保证值不会被移走
// 这样自引用的指针就始终有效
// Pin 的核心保证:
// 一旦值被 Pin,就不能获取 &mut T(因为 mem::swap 需要 &mut T)
// 只能通过 Pin<&mut T> 访问
}Unpin trait
use std::pin::Pin;
use std::marker::Unpin;
// Unpin 是一个自动 trait(auto trait)
// 大部分类型自动实现 Unpin,意味着"移动是安全的"
// 实现了 Unpin 的类型:i32, String, Vec, Box 等几乎所有常见类型
// 不实现 Unpin 的类型:大部分编译器生成的 Future(!Unpin)
fn move_pinned<T: Unpin>(pinned: Pin<&mut T>) -> &mut T {
// Unpin 类型可以从 Pin 中取出 &mut T
pinned.get_mut()
}
// !Unpin 类型不能从 Pin 中取出 &mut T
// fn move_not_unpin<T>(pinned: Pin<&mut T>) -> &mut T {
// pinned.get_mut() // 编译错误:T 可能不是 Unpin
// }
fn main() {
let mut data = String::from("hello");
let pinned = Pin::new(&mut data);
// String 是 Unpin 的,所以 Pin 对它没有实际限制
let r = pinned.get_mut();
r.push_str(" world");
println!("{}", r);
}| 概念 | 含义 |
|---|---|
Pin<P> | 包装指针 P,保证被指向的值不被移动 |
Unpin | 标记 trait:类型可以安全移动(Pin 对它无限制) |
!Unpin | 类型不能安全移动(Pin 真正起作用) |
Pin::new() | 创建 Pin,要求 T: Unpin |
Pin::new_unchecked() | 创建 Pin,unsafe,不要求 Unpin |
pin.get_mut() | 获取 &mut T,要求 T: Unpin |
Pin 在异步编程中的角色
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
// Future trait 的 poll 方法接收 Pin<&mut Self>
// pub trait Future {
// type Output;
// fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
// }
// 自定义 Future 示例
struct CountDown {
count: u32,
}
impl Future for CountDown {
type Output = String;
fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<String> {
if self.count == 0 {
Poll::Ready("完成".to_string())
} else {
self.count -= 1;
// 实际应用中这里应注册 waker
_cx.waker().wake_by_ref();
Poll::Pending
}
}
}
// CountDown 是 Unpin 的(没有自引用),所以 Pin 对它没限制
// 编译器生成的 async Future 通常是 !Unpin 的
fn main() {
println!("Future::poll 要求 Pin<&mut Self>");
println!("因为 async 块生成的 Future 可能包含自引用");
println!("Pin 保证 Future 在被 poll 期间不会被移动");
}pin! 宏和 Box::pin
use std::pin::Pin;
async fn example() -> i32 {
42
}
fn main() {
// 方式一:Box::pin — 堆上钉住
let future: Pin<Box<dyn Future<Output = i32>>> = Box::pin(example());
// Pin<Box<T>> 可以安全创建,因为 Box 拥有所有权且堆地址稳定
// 方式二:pin! 宏(std::pin::pin!)— 栈上钉住
// let pinned = std::pin::pin!(example());
// pin! 在栈上创建 Pin<&mut T>
// 手动 poll 需要 Pin
// 通常不需要手动处理,async/await 和运行时自动管理
println!("Box::pin 在堆上钉住 Future");
println!("pin! 宏在栈上钉住 Future");
}
use std::future::Future;常见追问
追问一:为什么 Future::poll 需要 Pin<&mut Self> 而不是 &mut Self?
因为 async 块生成的 Future 可能包含自引用(跨 await 的引用变成结构体字段)。如果 poll 之间 Future 被移动,自引用会悬垂。Pin 保证 Future 在被 poll 的整个过程中不会被移动。
追问二:PhantomPinned 是什么?
PhantomPinned 是一个零大小类型,实现了 !Unpin。将它作为结构体字段可以让整个结构体变为 !Unpin,从而让 Pin 真正起到限制作用。
追问三:日常异步编程需要手动处理 Pin 吗?
大部分情况不需要。async/await 语法和 tokio::spawn、Box::pin 等工具自动处理了 Pin。只有在实现自定义 Future 或底层异步原语时才需要直接操作 Pin。
基本示例
use std::pin::Pin;
use std::marker::PhantomPinned;
// 一个 !Unpin 的自引用结构体
struct SelfReferential {
data: String,
// 使用裸指针模拟自引用
ptr: *const String,
_pin: PhantomPinned, // 让类型变为 !Unpin
}
impl SelfReferential {
fn new(data: &str) -> Pin<Box<Self>> {
let res = SelfReferential {
data: data.to_string(),
ptr: std::ptr::null(),
_pin: PhantomPinned,
};
let mut boxed = Box::pin(res);
// 设置自引用指针
let self_ptr: *const String = &boxed.data;
unsafe {
let mut_ref = Pin::as_mut(&mut boxed);
Pin::get_unchecked_mut(mut_ref).ptr = self_ptr;
}
boxed
}
fn get_data(&self) -> &str {
&self.data
}
fn get_ptr_data(&self) -> &str {
unsafe { &*self.ptr }
}
}
fn main() {
let pinned = SelfReferential::new("hello");
// 数据一致:data 和 ptr 指向同一内容
println!("data: {}", pinned.get_data());
println!("ptr: {}", pinned.get_ptr_data());
// pinned 不能被移动(!Unpin + Pin)
// let moved = *pinned; // 编译错误
}常见问题
问题一:Pin 有运行时开销吗?
没有。Pin 是零大小的包装类型,所有限制都在编译期检查。生成的机器码与直接使用指针完全相同。
问题二:所有 Future 都是 !Unpin 的吗?
不是。手动实现的简单 Future(不含自引用)通常是 Unpin 的。只有编译器为 async 块生成的 Future(可能有跨 await 的引用)才是 !Unpin 的。
适用场景
- 异步编程:Future 在 poll 期间不能被移动
- 自引用结构体:保证内部指针始终有效
- FFI:固定内存地址供外部代码使用
- intrusive 数据结构:节点地址不能改变
注意事项
- Pin 对 Unpin 类型没有实际限制
- 大部分常见类型自动实现 Unpin
- async 块生成的 Future 通常是 !Unpin
- Box::pin 在堆上创建 Pin,pin! 在栈上创建
- PhantomPinned 让类型变为 !Unpin
- 日常 async/await 不需要手动处理 Pin
总结
Pin 防止值被移动,解决自引用结构体移动后内部指针悬垂的问题。Unpin 是自动 trait,标记"移动安全"的类型——Pin 对 Unpin 类型无限制。async 块生成的 Future 通常是 !Unpin 的(可能包含跨 await 的自引用),Future::poll 接收 Pin<&mut Self> 保证 poll 期间 Future 不被移动。Box::pin 在堆上钉住,pin! 宏在栈上钉住。PhantomPinned 让自定义类型变为 !Unpin。Pin 是编译期约束,零运行时开销。日常 async/await 开发不需要手动处理 Pin。