定海神针 Pin 和 Unpin
在 Rust 中，所有的类型可以分为两类:
- 类型的值可以在内存中安全地被移动，例如数值、字符串、布尔值、结构体、枚举，总之你能想到的几乎所有类型都可以落入到此范畴内
- 自引用类型，
为何需要 Pin
其实 Pin 还有一个小伙伴 UnPin ，与前者相反，后者表示类型可以在内存中安全地移动。在深入之前，我们先来回忆下 async/.await 是如何工作的:
let fut_one = /* ... */; // Future 1 let fut_two = /* ... */; // Future 2 async move { fut_one.await; fut_two.await; }
在底层，async 会创建一个实现了 Future 的匿名类型，并提供了一个 poll 方法：
// `async { ... }`语句块创建的 `Future` 类型 struct AsyncFuture { fut_one: FutOne, fut_two: FutTwo, state: State, } // `async` 语句块可能处于的状态 enum State { AwaitingFutOne, AwaitingFutTwo, Done, } impl Future for AsyncFuture { type Output = (); fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> { loop { match self.state { State::AwaitingFutOne => match self.fut_one.poll(..) { Poll::Ready(()) => self.state = State::AwaitingFutTwo, Poll::Pending => return Poll::Pending, } State::AwaitingFutTwo => match self.fut_two.poll(..) { Poll::Ready(()) => self.state = State::Done, Poll::Pending => return Poll::Pending, } State::Done => return Poll::Ready(()), } } } }
当 poll 第一次被调用时，它会去查询 fut_one 的状态，若 fut_one 无法完成，则 poll 方法会返回。未来对 poll 的调用将从上一次调用结束的地方开始。该过程会一直持续，直到 Future 完成为止。
然而，如果我们的 async 语句块中使用了引用类型，会发生什么？例如下面例子：
async { let mut x = [0; 128]; let read_into_buf_fut = read_into_buf(&mut x); read_into_buf_fut.await; println!("{:?}", x); }
这段代码会编译成下面的形式：
struct ReadIntoBuf<'a> { buf: &'a mut [u8], // 指向下面的`x`字段 } struct AsyncFuture { x: [u8; 128], read_into_buf_fut: ReadIntoBuf<'what_lifetime?>, }
这里，ReadIntoBuf 拥有一个引用字段，指向了结构体的另一个字段 x ，一旦 AsyncFuture 被移动，那 x 的地址也将随之变化，此时对 x 的引用就变成了不合法的，也就是 read_into_buf_fut.buf 会变为不合法的。
若能将 Future 在内存中固定到一个位置，就可以避免这种问题的发生，也就可以安全的创建上面这种引用类型。
struct Test { a: String, b: *const String, } impl Test { fn new(txt: &str) -> Self { Test { a: String::from(txt), b: std::ptr::null(), } } fn init(&mut self) { let self_ref: *const String = &self.a; self.b = self_ref; } fn a(&self) -> &str { &self.a } fn b(&self) -> &String { assert!(!self.b.is_null(), "Test::b called without Test::init being called first"); unsafe { &*(self.b) } } }
Unpin
事实上，绝大多数类型都不在意是否被移动，因此它们都自动实现了 Unpin 特征。
graph TB A(Pin<Pointer>)-->B[Pointer（e.g.Box<Data>）]-->C[Data];
实际上，Pin 不按套路出牌，它是一个结构体：
pub struct Pin<P> { pointer: P, }
它包裹一个指针，并且能确保该指针指向的数据不会被移动，例如 Pin<&mut T> , Pin<&T> , Pin> ，都能确保 T 不会被移动。
而 Unpin 才是一个特征，它表明一个类型可以随意被移动，可以被 Pin 住的值实现的特征是 !Unpin ，大家可能之前没有见过，!Unpin 说明类型没有实现 Unpin 特征，那自然就可以被 Pin 了。
例如 Pin<&mut u8> ，显然 u8 实现了 Unpin 特征，它可以在内存中被移动，因此 Pin<&mut u8> 跟 &mut u8 实际上并无区别，一样可以被移动。
- 都是标记特征( marker trait )，该特征未定义任何行为，非常适用于标记
- 都可以通过!语法去除实现
- 绝大多数情况都是自动实现, 无需我们的操心
深入理解 Pin
对于上面的问题，我们可以简单的归结为如何在 Rust 中处理自引用类型，下面用一个稍微简单点的例子来理解下 Pin :
#[derive(Debug)] struct Test { a: String, b: *const String, } impl Test { fn new(txt: &str) -> Self { Test { a: String::from(txt), b: std::ptr::null(), } } fn init(&mut self) { // 裸指针，进行自引用 let self_ref: *const String = &self.a; // 进行自引用 self.b = self_ref; } // 获取a字段的引用值 fn a(&self) -> &str { &self.a } // 获取b字段的引用值 fn b(&self) -> &String { assert!(!self.b.is_null(), "Test::b called without Test::init being called first"); unsafe { &*(self.b) } } }
Test 提供了方法用于获取字段 a 和 b 的值的引用。这里b 是 a 的一个引用，但是我们并没有使用引用类型而是用了裸指针，原因是：Rust 的借用规则不允许我们这样用，因为不符合生命周期的要求。 此时的 Test 就是一个自引用结构体。
如果不移动任何值，那么上面的例子将没有任何问题，例如:
fn main() { let mut test1 = Test::new("test1"); test1.init(); let mut test2 = Test::new("test2"); test2.init(); println!("a: {}, b: {}", test1.a(), test1.b()); println!("a: {}, b: {}", test2.a(), test2.b()); }
输出非常正常：
a: test1, b: test1 a: test2, b: test2
既然移动数据会导致指针不合法，那我们就移动下数据试试，将 test1 和 test2 进行下交换：
fn main() { let mut test1 = Test::new("test1"); test1.init(); let mut test2 = Test::new("test2"); test2.init(); println!("a: {}, b: {}", test1.a(), test1.b()); std::mem::swap(&mut test1, &mut test2); println!("a: {}, b: {}", test2.a(), test2.b()); }
按理来说，这样修改后，输出应该如下:
a: test1, b: test1 a: test1, b: test1、
但是实际运行后，却产生了下面的输出:
a: test1, b: test1 a: test1, b: test2
rust高级 异步编程 二 pin（2）https://developer.aliyun.com/article/1392112
