Rust为什么需要Pin、Unpin

1. 背景介绍

Rust 的所有权系统和借用检查器确保了内存安全，防止了常见的错误如悬空指针、数据竞争等。然而，在某些情况下，我们希望对象的内存地址保持不变，即防止对象被移动。这种需求在异步编程和自引用数据结构中尤为明显。

什么是移动语义？

在 Rust 中，值的所有权可以转移，称为“移动”。对于大多数类型，移动是安全的，编译器会自动处理相关的内存管理。然而，在某些情况下，移动对象可能会导致内存不安全。例如，当一个对象包含自引用指针时，移动该对象会导致指针指向无效的内存地址。为了解决这些问题，Rust 引入了 Pin 和 Unpin。

2. Pin 的作用与设计

什么是 Pin？

Pin 是一个标记类型，它确保被固定的对象在内存中不会被移动。Pin 的主要用途是在需要确保对象内存地址不变的场景下，防止对象的移动。

use std::pin::Pin;
use std::marker::PhantomPinned;
use std::ptr;

struct SelfReferential {
    data: String,
    ptr: *const String,
    _pin: PhantomPinned,
}

impl SelfReferential {
    fn new(data: &str) -> Self {
        SelfReferential {
            data: data.to_string(),
            ptr: ptr::null(),
            _pin: PhantomPinned,
        }
    }

    fn init_pin(self: Pin<&mut Self>) {
        let self_ptr: *const String = &self.data;
        // 安全：我们保证`self` 不会被移动
        unsafe {
            let mut_self = self.get_unchecked_mut();
            mut_self.ptr = self_ptr;
        }
    }

    fn print_ptr(&self) {
        unsafe {
            println!("Data: {}", *self.ptr);
        }
    }
}

fn main() {
    let mut s = SelfReferential::new("Hello, world!");
    
    // 使用 `Pin` 将对象固定
    let mut s = unsafe { Pin::new_unchecked(&mut s) };
    s.as_mut().init_pin();

    s.print_ptr();
}

为什么需要 Pin？

如上例所示，Pin 确保了结构体 SelfReferential 在被固定后不会被移动。这样，我们就可以安全地使用自引用指针（ptr），而不必担心对象被移动后指针变得无效。

3. Unpin 的作用与设计

什么是 Unpin？

Unpin 是一个自动实现的标记 trait。默认情况下，大多数类型都实现了 Unpin，这意味着这些类型的值可以在固定后继续被移动。换句话说，如果一个类型实现了 Unpin，即使它被 Pin 包装，也不会禁止它的移动。

use std::pin::Pin;

struct MyStruct {
    data: String,
}

fn move_struct<T>(val: T) -> T {
    val
}

fn main() {
    let mut s = MyStruct { data: String::from("Rust") };

    // 默认情况下，`MyStruct` 实现了 `Unpin`
    let pinned_s = Pin::new(&mut s);
    let s = move_struct(s); // 因为实现了 `Unpin`，可以自由移动

    // 编译器不会阻止这次移动
    println!("{}", s.data);
}

Unpin 如何与 Pin 协作？

在上面的代码中，MyStruct 类型自动实现了 Unpin，因此即使我们使用 Pin 将其固定，它仍然可以被移动。Pin 和 Unpin 的这种协作允许开发者灵活控制对象的移动性。

使用 !Unpin 的场景

在某些情况下，我们希望类型被 Pin 固定后不能再被移动。通过引入 PhantomPinned，我们可以防止 Rust 自动为类型实现 Unpin：

use std::pin::Pin;
use std::marker::PhantomPinned;

struct NoMove {
    data: String,
    _pin: PhantomPinned,
}

fn move_struct<T>(val: T) -> T {
    val
}

fn main() {
    let mut s = NoMove { data: String::from("No Move"), _pin: PhantomPinned };

    let pinned_s = Pin::new(&mut s);
    // let s = move_struct(s); // 编译错误，因为 `NoMove` 没有实现 `Unpin`

    // 使用 pinned_s 继续操作
    println!("{}", pinned_s.data);
}

在这里，NoMove 类型没有实现 Unpin，因此它在被固定后不能被移动。如果我们尝试移动它，编译器将报错。

4. 异步编程中的应用

在 Rust 的异步编程模型中，Pin 和 Unpin 尤其重要。Future trait 的 poll 方法要求 self 是 Pin<&mut Self>，确保在轮询期间对象不会被移动。

use std::pin::Pin;
use std::future::Future;
use std::task::{Context, Poll};

struct MyFuture {
    // 可以包含一些状态
}

impl Future for MyFuture {
    type Output = u32;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // 这里可以安全地访问固定的内存
        Poll::Ready(42)
    }
}

fn main() {
    let mut my_future = MyFuture {};
    let mut pinned_future = Box::pin(my_future);

    let waker = /* 创建或获取一个 waker */;
    let mut cx = Context::from_waker(&waker);

    let output = pinned_future.as_mut().poll(&mut cx);
    println!("Output: {:?}", output);
}

在这个例子中，我们创建了一个 MyFuture 结构体，并将其固定在堆上，确保它在异步任务执行期间不会被移动。

5. 结论

通过本文的讲解，我们了解了 Pin 和 Unpin 在 Rust 中的重要性及其实际应用。Pin 通过防止对象被移动来保证内存安全，而 Unpin 则提供了一种灵活的方式来控制哪些类型可以被移动。理解并正确使用这两个概念，对于编写高效、安全的异步代码尤为重要。

6. 参考文献与资料

• Rust 官方文档
• Rust 异步编程指南
• Rustonomicon