深入理解Rust中的Pinning机制（async-book项目解析）

什么是Pinning

Pinning（固定）是Rust中一种特殊的机制，它通过Pin<T>类型来确保某些对象不会被移动。这个概念在异步编程中尤为重要，特别是在处理Future时。当你看到Future::poll方法的签名self: Pin<&mut Self>时，这就是Pinning的应用场景。

为什么需要Pinning

自引用结构的问题

考虑以下异步代码：

async {
    let mut x = [0; 128];
    let read_into_buf_fut = read_into_buf(&mut x);
    read_into_buf_fut.await;
    println!("{:?}", x);
}

这段代码编译后会生成一个包含自引用字段的结构体。如果这个结构体被移动，内部的指针就会失效，导致未定义行为。

移动带来的风险

让我们看一个更简单的例子：

#[derive(Debug)]
struct Test {
    a: String,
    b: *const String,  // 指向a的指针
}

impl Test {
    fn new(txt: &str) -> Self {
        Test {
            a: String::from(txt),
            b: std::ptr::null(),
        }
    }
    
    fn init(&mut self) {
        self.b = &self.a;
    }
}

如果创建两个Test实例并交换它们：

let mut test1 = Test::new("test1");
test1.init();
let mut test2 = Test::new("test2");
test2.init();

std::mem::swap(&mut test1, &mut test2);

交换后，test2.b仍然指向test1.a，这就造成了悬垂指针。这就是为什么我们需要Pinning机制来防止这种移动。

Pinning的工作原理

Pin和Unpin

Pin<T>是一个包装指针的类型，它保证被指对象不会被移动（如果该对象实现了!Unpin）。与之对应的是Unpin trait，大多数类型都自动实现了这个trait，表示它们可以安全地被移动。

栈上固定

要在栈上固定一个!Unpin对象，需要使用unsafe代码：

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

#[derive(Debug)]
struct Test {
    a: String,
    b: *const String,
    _marker: PhantomPinned,  // 使类型实现!Unpin
}

let mut test1 = Test::new("test1");
let mut pinned = unsafe { Pin::new_unchecked(&mut test1) };

固定后尝试移动会导致编译错误：

std::mem::swap(pinned.get_mut(), test2.get_mut());  // 编译错误

堆上固定

更安全的做法是将对象分配在堆上：

impl Test {
    fn new(txt: &str) -> Pin<Box<Self>> {
        let t = Test {
            a: String::from(txt),
            b: std::ptr::null(),
            _marker: PhantomPinned,
        };
        let mut boxed = Box::pin(t);
        let self_ptr = &boxed.a;
        unsafe { boxed.as_mut().get_unchecked_mut().b = self_ptr };
        boxed
    }
}

堆分配的对象具有稳定地址，生命周期内不会被移动。

实际应用中的Pinning

处理Future

大多数异步函数生成的Future都是!Unpin的。当需要将它们传递给期望Unpin类型的函数时，需要先固定：

// 使用Box固定
let fut = async { /* ... */ };
let pinned = Box::pin(fut);

// 使用pin_mut!宏固定
let fut = async { /* ... */ };
pin_mut!(fut);

安全注意事项

1. 栈上固定依赖于开发者的unsafe保证，必须确保固定后对象不会被移动
2. 常见的错误是忘记隐藏原始变量，导致Pin被丢弃后对象被移动
3. 堆上固定更安全，因为对象生命周期内地址不会改变

总结

1. 对于T: Unpin的类型，Pin<T>等同于普通的引用
2. 获取!Unpin类型的可变引用需要unsafe
3. 标准库中的大多数类型都实现了Unpin
4. 由async/await生成的Future通常是!Unpin的
5. 可以使用Box::pin或pin_mut!宏来固定Future

理解Pinning机制对于编写正确的异步Rust代码至关重要，特别是在处理自引用结构和Future时。通过合理使用栈固定和堆固定，可以避免因对象移动导致的悬垂指针问题。