有些事情你總是學了又忘記（或者說你從來就沒學過？）

對我來說，其中之一就是在Rust中Pin/Unpin。

每次我讀到有關固定的解釋，我的大腦就像 ，幾周后就像 。

所以，我寫這篇文章是為了強迫我的大腦記住這些知識。我們看看效果如何！

Pin

Pin 是一種指針，可以看作是&mut T和&T之間的折中。Pin<&mut T>的重點是說：

1. 這個值可以被修改（就像&mut T一樣），但是
2. 這個值不能被移動（不像&mut T）

為什么？因為有些值必須不能移動，或者需要特別小心地去移動。

一個典型的例子就是自指數據結構。在使用async時，它們會自然地出現，因為未來值往往會在引用自己的本地值。


這個看似溫和的 Future：

async fn self_ref() { let mut v = [1, 2, 3]; let x = &mut v[0]; tokio::from_secs(1)).await; *x = 42; }

需要一個自我引用的結構，因為在底層，futures是狀態機（不像閉包）。

請注意，self_ref在第一個await處將控制權傳遞回調用者。這意味著盡管v和x看起來像普通的堆棧變量，但在這里可能發生了更復雜的事情。


編譯器希望生成類似這樣的內容：

enum SelfRefFutureState { Unresumed, // Created and wasn't polled yet. Returned, Poisoned, // `panic!`ed. SuspensionPoint1, // First `await` point. } struct SelfRefFuture { state: SelfRefFutureState, v: [i32; 3], x: &'problem mut i32, // a "reference" to an element of `self.v`, // which is a big problem if we want to move `self`. // (and we didn't even consider borrowchecking!) }


但是！如果你想的話，你可以移動SelfRefFuture，這會導致x指向無效的內存。

let f = self_ref(); let boxed_f = Box::new(f); // Evil? let mut f1 = self_ref(); let mut f2 = self_ref(); std::swap(&mut f1, &mut f2); // Blasphemy?

怎么回事？就像一位聰明的編譯器曾經說過的：

futures do nothing unless you.awaitorpollthem#[warn(unused_must_use)]on by default – rustc

這是因為調用self_ref實際上什么都不做, 我們實際上會得到類似于:

struct SelfRefFuture { state: SelfRefFutureState, v: MaybeUninit<[i32; 3]>, x: *mut i32, // a pointer into `self.v`, // still a problem if we want to move `self`, but only after it is set. // // .. other locals, like the future returned from `tokio::sleep`. }


那么在這種狀態(初始狀態)下可以安全地移動。

impl SelfRefFuture { fn new() -> Self { Self { state: SelfRefFutureState::Unresumed, v: MaybeUninit::uninit(), x: std::null_mut(), // .. } } }


只有當我們開始在f上進行輪詢時，我們才會遇到自我引用的問題（x指針被設置），但如果 f 被包裹在Pin中，所有這些移動都變成了unsafe，這正是我們想要的。 由于許多futures 一旦執行就不應該在內存中移動，只有將它們包裝在Pin中才能安全地使用，因此與異步相關的函數往往接受Pin<&mut T>（假設它們不需要移動該值）。

一個微小的例子

這里不需要固定：

use tokio::timeout; async fn with_timeout_once() { let f = async { 1u32 }; let _ = timeout(Duration::from_secs(1), f).await; }


但是如果我們想要多次調用 timeout （例如，因為我們想要重試），我們將不得不使用&mut f（否則會得到use of moved value），這將導致編譯器報錯

use tokio::timeout; async fn with_timeout_twice() { let f = async { 1u32 }; // error[E0277]: .. cannot be unpinned, consider using `Box::pin`. // required for `&mut impl Future ` to implement `Future`let _ = timeout(Duration::from_secs(1), &mut f).await; // An additional retry. let _ = timeout(Duration::from_secs(1), &mut f).await; }


為什么？ 因為在幾個層級下，timeout調用了被定義為Future::poll的函數

fn poll(self: Pin<&mut Self>, ...) -> ... { ... }


當我們awaitf時，我們放棄了對它的所有權。 編譯器能夠為我們處理固定引用，但如果我們只提供一個&mut f，它就無法做到這一點，因為我們很容易破壞 Pin 的不變性：

use tokio::timeout; async fn with_timeout_twice_with_move() { let f = async { 1u32 }; // error[E0277]: .. cannot be unpinned, consider using `Box::pin`. let _ = timeout(Duration::from_secs(1), &mut f).await; // .. because otherwise, we could move `f` to a new memory location, after it was polled! let f = *Box::new(f); let _ = timeout(Duration::from_secs(1), &mut f).await; }


這個時候我們需要給 future 套上一個pin!

use tokio::pin; use tokio::timeout; async fn with_timeout_twice() { let f = async { 1u32 }; pin!(f); // f is now a `Pin<&mut impl Future >`.let _ = timeout(Duration::from_secs(1), &mut f).await; let _ = timeout(Duration::from_secs(1), &mut f).await; }



這里還需要再做一點額外的工作，我們需要確保f在被 pin 包裹之后不再可訪問。如果我們看不到它，就無法移動它。 事實上我們可以更準確地表達不能移動規則：指向的值在值被丟棄之前不能移動（無論何時丟棄Pin）。


這就是pin!宏的作用：它確保原始的f對我們的代碼不再可見，從而強制執行Pin的不變性 Tokio’spin!是這樣實現的:

// Move the value to ensure that it is owned let mut f = f; // Shadow the original binding so that it can't be directly accessed // ever again. #[allow(unused_mut)] let mut f = unsafe { Pin::new_unchecked(&mut f) };


標準庫的版本pin!有點更酷，但使用的是相同的原理：用新創建的Pin來遮蔽原始值，使其無法再被訪問和移動。

一個

所以Pin是一個指針（對另一個指針的零大小的包裝器），它有點像&mut T但有更多的規則。 下一個問題將是“歸還借用的數據”。 我們無法回到以前的固定未來

use std::Future; async fn with_timeout_and_return() -> impl Future { let f = async { 1u32 }; pin!(f); // f is now a `Pin<&mut impl Future>`.let s = async move { let _ = timeout(Duration::from_secs(1), &mut f).await; }; // error[E0515]: cannot return value referencing local variable `f` s }


現在應該更清楚為什么了：被固定的f現在是一個指針，它指向的數據（異步閉包）在我們從函數返回后將不再存在。 因此，我們可以使用Box::pin

-pin!(f); +let mut f = Box::pin(f);


但是我們剛剛不是說Pin<&mut T>是&mut T和&T之間的（一個包裝器）指針嗎？ 嗯，一個mut Box也像一個&mut T，但有所有權。 所以一個Pin>是一個指向可變Box和不可變Box之間的指針，值可以被修改但不能被移動。

Unpin

Unpin是一種 Trait。它不是Pin的"相反"，因為Pin是指針的一種類型，而特征不能成為指針的相反。


Unpin也是一個自動特性（編譯器在可能的情況下會自動實現它），它標記了一種類型，其值在被固定后可以被移動（例如，它不會自我引用）。


主要的觀點是，如果T: Unpin，我們總是可以Pin::new和Pin::{into_inner,get_mut}T 的值，這意味著我們可以輕松地在“常規”的可變值之間進行轉換，并忽略直接處理固定值所帶來的復雜性。

UnpinTrait 是Pin的一個重要限制，也是Box::pin如此有用的原因之一：當T: !Unpin時，“無法移動或替換Pin>的內部”，因此Box::pin（或者更準確地說是Box::into_pin）可以安全地調用不安全的Pin::new_unchecked，而得到的Box總是Unpin的，因為移動它時并不會移動實際的值。


這里說的很繞，我們用例子例子解釋一下。

另一個微小的例子

我們可以親手創造一個美好的 Future：

fn not_self_ref() -> impl Future u32> + Unpin { struct Trivial {} impl Future for Trivial { type Output = u32; fn poll(self: Pin<&mut Self>, _cx: &mut std::Context<'_>) -> std::Poll { std::Ready(1) } } Trivial {} }

現在，我們可以多次調用它而不需要固定： timeout

async fn not_self_ref_with_timeout() { let mut f = not_self_ref(); let _ = timeout(Duration::from_secs(1), &mut f).await; let _ = timeout(Duration::from_secs(1), &mut f).await; }


使用async fn或async {}語法創建的任何 Future 都被視為!Unpin，這意味著一旦我們將其放入Pin中，就無法再取出來。

摘要

• Pin是對另一個指針的包裝，有點像&mut T，但額外的規則是在值被丟棄之前，移動它所指向的值是不安全的。
• 為了安全地處理自引用結構，我們必須在設置自引用字段后防止其移動(使用Pin)。
• Pin 承諾該值在其生命周期內無法移動，所以我們無法在不放棄創建&mut T的能力并破壞Pin的不變性的情況下創建它。
• 當在擁有所有權的 Future 進行awaitFuture 時，編譯器可以處理固定，因為它知道一旦所有權轉移，Future就不會移動。
• 否則，我們需要處理固定（例如使用pin!或Box::pin）
• Unpin是一個標記特征，表示一個類型即使在被包裝在Pin之后仍然可以安全地移動，使一切變得更簡單。
• 大多數結構是Unpin，但async fn和async {}總是產生!Unpin結構。