Pin/Unpin 核心概念 ​

面试题 ​

请解释 Rust 中 Pin 和 Unpin 的作用,为什么异步编程需要 Pin?

考察意图 ​

Pin/Unpin 是 Rust 异步编程中最难理解的概念之一。面试官想看候选人能否解释自引用结构体的问题、Pin 如何防止值被移动,以及 Unpin 作为"可以安全移动"标记的含义。

答题要点 ​

自引用结构体的问题 ​

rust
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 的作用 ​

rust
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 ​

rust
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 在异步编程中的角色 ​

rust
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 ​

rust
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。

基本示例 ​

rust
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。