六 Pin

概述

译者注: Pin是在使用Future时一个非常重要的概念,我的理解是: 通过使用Pin,让用户无法安全的获取到&mut T,进而无法进行上述例子中的swap. 如果你觉得你的和这个struct没有自引用的问题,你可以自己实现UnPin.

1. 了解如何使用Pin以及当你自己实现Future的时候为什么需要Pin
   
2. 理解如何让自引用类型被安全的使用
   
3. 理解跨'await`借用是如何实现的
   
4. 制定一套实用的规则来帮助你使用Pin
   

定义

这个命名方案是 Rusts 的安全特性之一，它故意测试您是否因为太累而无法安全地使用这个标记来实现类型。如果你因为UnPin开始感到困惑，或者甚至生气，那么你就应该这样做！是时候放下工作，以全新的心态重新开始明天的生活了，这是一个好兆头。

Pinning和自引用结构

use std::pin::Pin;
  #[derive(Debug)]struct Test {    a: String,    b: *const String,}
impl Test {    fn new(txt: &str) -> Self {        let a = String::from(txt);        Test {            a,            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 {        unsafe {&*(self.b)}    }}

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: test1a: test2, b: 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: test1a: test1, b: test1

但是实际上我们得到的是:

a: test1, b: test1a: test1, b: 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);    test1.a = "I've totally changed now!".to_string();    println!("a: {}, b: {}", test2.a(), test2.b());
}

固定在栈上

use std::pin::Pin;use std::marker::PhantomPinned;
 #[derive(Debug)]struct Test {    a: String,    b: *const String,    _marker: PhantomPinned,}

impl Test {    fn new(txt: &str) -> Self {        let a = String::from(txt);        Test {            a,            b: std::ptr::null(),            // This makes our type `!Unpin`            _marker: PhantomPinned,        }    }    fn init<'a>(self: Pin<&'a mut Self>) {        let self_ptr: *const String = &self.a;        let this = unsafe { self.get_unchecked_mut() };        this.b = self_ptr;    }
    fn a<'a>(self: Pin<&'a Self>) -> &'a str {        &self.get_ref().a    }
    fn b<'a>(self: Pin<&'a Self>) -> &'a String {        unsafe { &*(self.b) }    }}

pub fn main() {    // test1 is safe to move before we initialize it    let mut test1 = Test::new("test1");    // Notice how we shadow `test1` to prevent it from beeing accessed again    let mut test1 = unsafe { Pin::new_unchecked(&mut test1) };    Test::init(test1.as_mut());
    let mut test2 = Test::new("test2");    let mut test2 = unsafe { Pin::new_unchecked(&mut test2) };    Test::init(test2.as_mut());
    println!("a: {}, b: {}", Test::a(test1.as_ref()), Test::b(test1.as_ref()));    println!("a: {}, b: {}", Test::a(test2.as_ref()), Test::b(test2.as_ref()));}

pub fn main() {    let mut test1 = Test::new("test1");    let mut test1 = unsafe { Pin::new_unchecked(&mut test1) };    Test::init(test1.as_mut());
    let mut test2 = Test::new("test2");    let mut test2 = unsafe { Pin::new_unchecked(&mut test2) };    Test::init(test2.as_mut());
    println!("a: {}, b: {}", Test::a(test1.as_ref()), Test::b(test1.as_ref()));    std::mem::swap(test1.get_mut(), test2.get_mut());    println!("a: {}, b: {}", Test::a(test2.as_ref()), Test::b(test2.as_ref()));}

需要注意的是，栈pinning总是依赖于我们所在的当前栈帧，因此我们不能在一个栈帧中创建一个自引用对象并返回它，因为任何指向“self”的指针都是无效的。
如果你把一个值固定在一个栈上，这也会让你承担很多责任。一个很容易犯的错误是，忘记对原始变量进行阴影处理，因为这样可以在初始化后drop固定的指针并访问原来的值:

fn main() {
   let mut test1 = Test::new("test1");
   let mut test1_pin = unsafe { Pin::new_unchecked(&mut test1) };
   Test::init(test1_pin.as_mut());
   drop(test1_pin);

   let mut test2 = Test::new("test2");
   mem::swap(&mut test1, &mut test2);
   println!("Not self referential anymore: {:?}", test1.b);
}

固定在堆上

use std::pin::Pin;use std::marker::PhantomPinned;
 #[derive(Debug)]struct Test {    a: String,    b: *const String,    _marker: PhantomPinned,}
impl Test {    fn new(txt: &str) -> Pin<Box<Self>> {        let a = String::from(txt);        let t = Test {            a,            b: std::ptr::null(),            _marker: PhantomPinned,        };        let mut boxed = Box::pin(t);        let self_ptr: *const String = &boxed.as_ref().a;        unsafe { boxed.as_mut().get_unchecked_mut().b = self_ptr };
        boxed    }
    fn a<'a>(self: Pin<&'a Self>) -> &'a str {        &self.get_ref().a    }
    fn b<'a>(self: Pin<&'a Self>) -> &'a String {        unsafe { &*(self.b) }    }}
pub fn main() {    let mut test1 = Test::new("test1");    let mut test2 = Test::new("test2");
    println!("a: {}, b: {}",test1.as_ref().a(), test1.as_ref().b());    println!("a: {}, b: {}",test2.as_ref().a(), test2.as_ref().b());}

Pinning的一些实用规则

1. 针对T:UnPin(这是默认值),Pin<'a,T>完全定价与&'a mut T. 换句话说: UnPin意味着这个类型即使在固定时也可以移动，所以Pin对这个类型没有影响。
   
2. 针对T:!UnPin,从Pin< T>获取到&mut T,则必须使用unsafe. 换句话说,!Unpin能够阻止API的使用者移动T,除非他写出unsafe的代码.
   
3. Pinning对于内存分配没有什么特别的作用，比如将其放入某个“只读”内存或任何奇特的内存中。它只使用类型系统来防止对该值进行某些操作。
   
4. 大多数标准库类型实现 Unpin。这同样适用于你在 Rust 中遇到的大多数“正常”类型。Future和Generators是两个例外。
   
5. Pin的主要用途就是自引用类型,Rust语言的所有这些调整就是为了允许这个. 这个API中仍然有一些问题需要探讨.
   
6. !UnPin这些类型的实现很有可能是不安全的. 在这种类型被钉住后移动它可能会导致程序崩溃。在撰写本书时，创建和读取自引用结构的字段仍然需要不安全的方法(唯一的方法是创建一个包含指向自身的原始指针的结构)。
   
7. 当使用nightly版本时,你可以在一个使用特性标记在一个类型上添加!UnPin. 当使用stable版本时,可以将std: : marker: : PhantomPinned 添加到类型上。
   
8. 你既可以固定一个栈上的对象也可以固定一个堆上的对象.
   
9. 将一个!UnPin的指向栈上的指针固定需要unsafe.
   
10. 将一个!UnPin的指向堆上的指针固定,不需要unsafe,可以直接使用Box::Pin.
    

不安全的代码并不意味着它真的“unsafe” ，它只是减轻了通常从编译器得到的保证。一个不安全的实现可能是完全安全的，但是您没有编译器保证的安全网。

映射/结构体的固定

Pin和Drop

把它们放在一起

奖励部分

 #![feature(optin_builtin_traits, negative_impls)] // needed to implement `!Unpin`use std::pin::Pin;
pub fn main() {    let gen1 = GeneratorA::start();    let gen2 = GeneratorA::start();    // Before we pin the pointers, this is safe to do    // std::mem::swap(&mut gen, &mut gen2);
    // constructing a `Pin::new()` on a type which does not implement `Unpin` is    // unsafe. A value pinned to heap can be constructed while staying in safe    // Rust so we can use that to avoid unsafe. You can also use crates like    // `pin_utils` to pin to the stack safely, just remember that they use    // unsafe under the hood so it's like using an already-reviewed unsafe    // implementation.
    let mut pinned1 = Box::pin(gen1);    let mut pinned2 = Box::pin(gen2);
    // Uncomment these if you think it's safe to pin the values to the stack instead    // (it is in this case). Remember to comment out the two previous lines first.    //let mut pinned1 = unsafe { Pin::new_unchecked(&mut gen1) };    //let mut pinned2 = unsafe { Pin::new_unchecked(&mut gen2) };
    if let GeneratorState::Yielded(n) = pinned1.as_mut().resume() {        println!("Gen1 got value {}", n);    }        if let GeneratorState::Yielded(n) = pinned2.as_mut().resume() {        println!("Gen2 got value {}", n);    };
    // This won't work:    // std::mem::swap(&mut gen, &mut gen2);    // This will work but will just swap the pointers so nothing bad happens here:    // std::mem::swap(&mut pinned1, &mut pinned2);
    let _ = pinned1.as_mut().resume();    let _ = pinned2.as_mut().resume();}
enum GeneratorState<Y, R> {    Yielded(Y),    Complete(R),}
trait Generator {    type Yield;    type Return;    fn resume(self: Pin<&mut Self>) -> GeneratorState<Self::Yield, Self::Return>;}
enum GeneratorA {    Enter,    Yield1 {        to_borrow: String,        borrowed: *const String,    },    Exit,}
impl GeneratorA {    fn start() -> Self {        GeneratorA::Enter    }}
// This tells us that the underlying pointer is not safe to move after pinning.// In this case, only we as implementors "feel" this, however, if someone is// relying on our Pinned pointer this will prevent them from moving it. You need// to enable the feature flag ` #![feature(optin_builtin_traits)]` and use the// nightly compiler to implement `!Unpin`. Normally, you would use// `std::marker::PhantomPinned` to indicate that the struct is `!Unpin`.impl !Unpin for GeneratorA { }
impl Generator for GeneratorA {    type Yield = usize;    type Return = ();    fn resume(self: Pin<&mut Self>) -> GeneratorState<Self::Yield, Self::Return> {        // lets us get ownership over current state        let this = unsafe { self.get_unchecked_mut() };            match this {            GeneratorA::Enter => {                let to_borrow = String::from("Hello");                let borrowed = &to_borrow;                let res = borrowed.len();                *this = GeneratorA::Yield1 {to_borrow, borrowed: std::ptr::null()};
                // Trick to actually get a self reference. We can't reference                // the `String` earlier since these references will point to the                // location in this stack frame which will not be valid anymore                // when this function returns.                if let GeneratorA::Yield1 {to_borrow, borrowed} = this {                    *borrowed = to_borrow;                }
                GeneratorState::Yielded(res)            }
            GeneratorA::Yield1 {borrowed, ..} => {                let borrowed: &String = unsafe {&**borrowed};                println!("{} world", borrowed);                *this = GeneratorA::Exit;                GeneratorState::Complete(())            }            GeneratorA::Exit => panic!("Can't advance an exited generator!"),        }    }}

1. 将值装箱，从而在堆上分配它
   
2. 使用unafe然后把值固定到栈上。用户知道如果他们事后移动了这个值，那么他们在就违反了当他们使用unsafe时候做出的承诺,也就是一直持有.