rust-course/advance/async/pin-unpin

[giscus[bot]]

advance/async/pin-unpin

https://course.rs/advance/async/pin-unpin.html

[artorias1024]

好难，始终对pin理解的不太好

[oleolema]

let mut test1 = Test::new("test1");
    test1.init();
    let mut test2 = Test::new("test2");
    test2.init();
    println!("a: {}, b: {}, {:?}", test1.a(), test1.b(), test1.b);
    test1.a = "hello".to_string();
    println!("a: {}, b: {}, {:?}", test1.a(), test1.b(), test1.b);
}

a: test1, b: test1, 0x7f3d249d96a0
a: hello, b: hello, 0x7f3d249d96a0

为什么这里改了a，b也变了呢

[oleolema]

let mut test1 = Test::new("test1");
    test1.init();
    let mut test2 = Test::new("test2");
    test2.init();
    println!("{:?}", &test1.a as *const String);
    println!("{:?}", &test1.a[..] as *const str);
    println!("{:?}", test1.a.as_ptr());
    println!(
        "a: {}, {:?}, {:?}, b: {}, {:?}",
        test1.a(),
        &test1.a as *const String,
        test1.a.as_ptr(),
        test1.b(),
        test1.b
    );
    std::mem::swap(&mut test1, &mut test2);
    println!(
        "a: {}, {:?}, {:?}, b: {}, {:?}",
        test1.a(),
        &test1.a as *const String,
        test1.a.as_ptr(),
        test1.b(),
        test1.b
    );

0x7f9f221fe570
0x7f9f1c000c30
0x7f9f1c000c30
a: test1, 0x7f9f221fe570, 0x7f9f1c000c30, b: test1, 0x7f9f221fe570
a: test2, 0x7f9f221fe570, 0x7f9f1c000c50, b: test1, 0x7f9f221fe590

问下各位大佬，为什么 const String 指针在内存交换前后都没变化，而const str就确实发生了交换

[ADkun]

同问，为什么*const String在swap之后并没有改变，是否是因为*const String的存储位置不一样？

[fadedzipper]

&test1.a 表示栈上的地址，test1.a.as_ptr() 还有test1.a[..]表示堆上的内容了。
test本身存储在栈上，test1.a的地址当然一直没有变，但是它的内容变了。指向了新的堆上的内容。
std::mem::swap的实现去看一看。它只交换两个参数（指针）直接指向的确定大小（类型可能是动态大小，但是类型的控制结构（那个胖指针）的大小是一定的，因为它可以被放在栈上。）的内容。而不去管这个直接指向的内容里面有没有指针。有没有指针，这个内部用到了unsafe的函数都是安全的。很有意思。

[TsGanT]

swap交换的是指针所指向的值，因此指针本身的值肯定不会变：https://doc.rust-lang.org/stable/std/mem/fn.swap.html
Swaps the values at two mutable locations, without deinitializing either one.

[zzps]

图上的内存地址分别代表什么的地址，红色箭头的指向代表什么意思希望能标注或者注释下，看不太懂。因为我原先理解“移到”的意思是一个不能浅拷贝的变量值从绑定a变量换到绑定b变量，变量值内存地址是不变的，变的是b有个指向变量值的地址而且拥有所有权。而在这里貌似变量值的地址也变了，这样的话会涉及到重新分配堆内存，效率肯定低的，应该不会这么设计，所以想借助上面的图来理解值移到到底是移到的啥

[mumumusuc]

你可能是考虑太多了，就mem::swap而言就是把Test1的数据拷贝到Test2的地址，Test2的数据拷贝到了Test1的地址。

图

&test1 == 0x1001;      // test1地址是0x1001
&test1.a == 0x1002;   // test1.a地址是0x1002
test1.a == 0x1111 -> "test1" // test1.a的值是地址0x1111，地址0x1111存储着字符串“test1”
&test1.b == 0x1003;   // test.b的地址是0x1003
test.b == &test.a == 0x1002; //test.b的值是0x1002，也就是test.a的地址

[UndertakeU]

确实，rust中swap是值拷贝，内存地址不变，仅仅是拷贝后的值发生变化，其中0x1002一直是变量a的地址，0x1003一直是指针变量b地址

1. 0x1002地址的值从0x2222（0x2222保存值是test2）
2. 0x1003地址的值变形为0x2002，0x2002现在保存值0x1111（0x1111保存值是test1）

[runsisi]

看了大量的文章好像都没有说清楚一个问题（或者说没有让我看明白）：到底 pin 是 1）将 move 之后的 invalid 指针重新变成了 valid，还是 2）仅仅是阻止代码构建？

将值固定到栈上 的例子让我感觉实现的是 2），固定到堆上 的例子则有些莫名其妙，打印一下就完事了，不应该和 将值固定到栈上 的例子要对应以来吗，不 swap 一下啥的吗？

谢谢～～

[mumumusuc]

在堆和栈上没什么区别，Pin做的就是利用编译器规则尽量保证你没有手段移动内存。换句话说，只要你写的代码足够unsafe，Pin跟没有一样:)。

#![feature(box_syntax)]
use core::pin::Pin;
use core::marker::PhantomPinned;

#[derive(Debug)]
struct Test{
    x: i32,
    _marker: PhantomPinned,
}

impl Test{
    fn new(x:i32) -> Self {
        Test{x, _marker:PhantomPinned}
    }
}

fn main() {
    // 裸指针
    let p0 = Box::leak(box Test::new(0));
    let mut p1 = box Test::new(1);
    // 绕过借用规则从裸指针构造Pin
    let p2 = unsafe {
       Pin::new_unchecked( &mut *core::ptr::addr_of_mut!( *p0 ) )
    };
    // 由于没有shadow掉p0，我们现在拥有了p0所指内存的两个可变指针
    // Ok！交换p0和p1，p2所Pin的内存也随之改变
    std::mem::swap(p0, &mut p1);
    // 1，0，1
    println!("{:?}, {:?}, {:?}", p0 , p1, p2);
    
    // Bad！编译器阻止了我们使用p2的可变引用
    //std::mem::swap(p2.get_mut(), &mut p1);
    //println!("{:?}, {:?}", p0 , p1);
    
    // Ok！我们向编译器声明要使用unsafe，交换成功
    unsafe {
      std::mem::swap(p2.get_unchecked_mut(), &mut p1);
    }
    // 0，1
    println!("{:?}, {:?}", p0 , p1); 
}

[runsisi]

非常感谢～

我学习 Pin 的出发点是理解为何在 tokio 中 future 需要调用 tokio::pin 的本质原因是什么。

我再消化消化，感觉有点像课堂教学哈，老师讲台上讲的飞起，但是下面的同学们却没有理解这个理论（Pin）为什么可以应用到特定的实践场景（tokio）中：）

[ruaruagerry]

Test的例子确实会带来这种思考：Pin做的事情好像只是报错、并没有解决什么问题。
我起初也有一样的疑问，我看了下最上方Rustln的回答后，结合我个人的思考：
Pin做的事情，就是制定一个编译器规则，让你在使用自引用类型的时候给予帮助/提示，防止你写出异常的代码。

[dangxia]

我也是，刚开始理解“固定”这个词以为是真的是固定住，直到了看到：https://cfsamson.github.io/books-futures-explained/5_pin.html#practical-rules-for-pinning 的第三条：Pinning does nothing special with memory allocation like putting it into some "read only" memory or anything fancy. It only uses the type system to prevent certain operations on this value.

[fadedzipper]

确实，我理解Pin的目的是 防止 在T是!unpin的时候，安全获得Pin<P>里面，T的所有权和可变引用。那么T自然就是不可以移动的了。但是Pin本身是一个指针，只是包装了一下P，所以它是可以移动的。Pin的目的是把一个移动就会出错的结构，变成移动它的指针，这样就不会出错。
在swap的例子，就是获得自引用结构的可变引用导致出错了。
在栈的错误例子里面，就是Pin并没有获得T的所有权，导致T被它的所有者随意改了，Pin并没有发挥到它的作用。

[FEFD66]

所以说 Future的实现 只要是Pin<T>就行，至于有没有实现!Unpin是不管的，只要保证不会被move掉就行。就是Pin<Box<T>>的来源
这样理解对吗？

[ruaruagerry]

讲清楚这个问题，其实需要讲解为啥有时候Future需要!Unpin，有时候又需要Unpin。
很可惜目前俺也没办法完整的给出答案，只能粗略的根据个人理解回答下，有些框架的Future实现不涉及到自引用，有些框架的Future又涉及到自引用。

[pphboy]

我真看不懂，看了两遍

新手

[zhwei820]

这里彻底晕了

[Kotodian]

rust中Future是通过Generator实现的,看了下Generator生成的时候用了std::mem::replace来查看状态,但是参数命名是Pin的,为什么能调用std::mem::replace

[wuhaiji]

真的晕了。。。rust的各种指针好难记

[ruaruagerry]

道法自然，不用拘泥于形式，搞清楚原理就行。至于怎么用，真正用的时候再来查就行了。

[1793523411]

晕了

[Dawson-Jones]

但是实际运行后，却产生了下面的输出

[Dawson-Jones]

这个地方写错了

但是实际运行后，却产生了下面的输出:

a: test1, b: test1
a: test1, b: test2

应改为

a: test2, b: test1
a: test1, b: test2

应该将第一个 a：

[mcfd]

那是你将
std::mem::swap放在了俩次打印之前
原文是在俩次之间

[xianfuxing]

https://folyd.com/blog/rust-pin-unpin/ 加深理解

[sinopec]

这个终于说清楚了。。。

[cctyl]

支持一个，这个讲的很好，建议纳入

[horsefaced]

看了一下Pin的官方说明, 其实 Pin 这个结构体并不是让 Pin 中的值变的不可移动, 而是让你无法在不使用 unsafe 方法的前提下改动 Pin 中的值地址而已. 真正标志一个值是不是不可移动的只有 !Unpin 这个标志. 这就是为什么 Pin 只是一个结构体, 而 Unpin 是一个编译器自动实现的 trait 的原因.

[fadedzipper]

说的对，有一个小问题，Pin中的值实现Unpin trait 的时候可以safe的获得可变引用。

[taiiiyang]

被pin住的堆上数据就不会发生移动了吗

[stolen-programmer]

仍然可以移动 只要你写的足够unsafe
#788 (comment)

[ranqiwei]

已经麻了，这节。

[ChitandaEru7]

    std::mem::swap(&mut test1, &mut test2);
    println!("a: {}, b: {}", test1.a(), test1.b());
    println!("a: {}, b: {}", test2.a(), test2.b());

输出

a: test2, b: test1
a: test1, b: test2

本身不难理解，互换后的俩value都打出来就好理解为什么要pin了，swap之后a的值互换，b指向的目标互换；

[Raobian]

这个Pin，Box，Arc起名真的是一眼明了。实在不行就叫i j k多好

[Alkaidd]

是我漏看了吗，好像一直看到现在也没有讲到虚类型？

[ycchanau]

#[derive(Debug)]
struct Test {
    data: String,
    rData: *const String, // rData 是一个裸指针，引用了 data 的值
}

fn main() {
    let str = String::from("数据");

    let mut test = Test {
        data: str, // 1. 这里 str 的所有权转移到了这里，所以 rData 赋值为 &str 是会抛出所有权错误
        rData: std::ptr::null(), // 2. 所以这里，我们先初始化一个空指针
    };

    // 3. 获取 test.data 的引用然后再设置给 rData
    test.rData = &test.data; // 4. 此时 rData 的值为 0xc3560ff8c0
    println!("{:?}", test);

    // 现在的问题来了！！！！！！！！！！！
    // 如果我把 data 的值改变了呢？！！！！
    // 那 rData 会怎么样？
    test.data = String::from("我是修改后的数据");
    println!("{:?}", test); // 5. 此时 rData 的值还是 0xc3560ff8c0 ！！！！！没有变！

    println!("{:?}", unsafe { &*test.rData });


}

Test { data: "数据", rData: 0x25ed4ff510 }
Test { data: "我是修改后的数据", rData: 0x25ed4ff510 }
"我是修改后的数据"

所以問題在哪裏？rdata不是正確嗎？

[stolen-programmer]

没看出有什么问题 指针又不归rust管

[cctga]

啊？你的意思是你改了 data，想让 rData 也跟着改？这肯定不会跟着改啊

[vince-1998]

emo了

[tyz-own]

看了评论区大佬的留言，有一些看法，望指正：
在 "将固定住的 Future 变为 Unpin" 这里，Pin 是一个包装着 ”不可移动类型的指针“ ( eg: Box) 的类型 ，被 Pin 中的指针包装的类型不能被移动， 但 Pin 的指针可以被移动和使用。

[wangzaixiang]

pub fn main() {
    // 此时的`test1`可以被安全的移动
    let mut test1 = Test::new("test1");
    // 新的`test1`由于使用了`Pin`，因此无法再被移动，这里的声明会将之前的`test1`遮蔽掉(shadow)
    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()));
    // ??? 如果需要修改 test1.a 呢？ 必须通过 test1.as_mut().get_unchecked_mut() 来获得 &mut 借用
    // 那如果能够通过 test1.as_mut().get_unchecked_mut() 获得 &mut 借用, swap 也无法防止移动
    std::mem::swap(test1.get_mut(), test2.get_mut());
    println!("a: {}, b: {}", Test::a(test2.as_ref()), Test::b(test2.as_ref()));
}

我的疑问写在这段代码里面：Pin 是通过阻止或得 &mut 借用来防止 swap 的，可是正常的变更操作（Future对象执行期间肯定会发生状态变更），还是需要通过 unsafe的方式来获取 &mut 借用。没有感觉到Pin起到了什么作用？

[G00dFuture]

深入理解Pin的例子中，运行结果不是
a: test1, b: test1
a: test1, b: test2

我实际运行后是
a: test2, b: test1
a: test1, b: test2

[zegzag]

啊啊啊啊啊

[ADkun]

Pin的“定住”的基础就是

pub fn get_mut(self) -> &'a mut T
where
    T: Unpin

pub unsafe fn get_unchecked_mut(self) -> &'a mut T

观察签名，get_mut只有在定住的类型实现了Unpin时才能在安全代码中调用。
而实现了!Unpin的类型只能通过unsafe来使用get_unchecked_mut，也就是说Pin其实是避免你在安全代码中调用get_mut，从而防止类似于std::mem::swap(&mut a, &mut b)导致值被移动，并且这种检查是编译期检查。

[cctga]

感觉看不太懂，我的理解 Pin 的作用就是不让你在 safe 中使用 &mut T，从而不能使用 swap 这样的代码，从而防止你对 Future 对象使用 swap 这样的代码

[buchenglei]

我的理解是 Pin最根本的目的是阻止获得未实现 Unpin 类型的可变引用，如果拿不到可变引用，自然就被牢牢钉住 (至于原因，上面的内容应该解释的比较清楚了)

1. 无法通过 &mut xxx 获取Pin内部未实现Unpin类型的可变引用

本质上 Pin 是一个智能指针，它实现了 DerefMut，但是只针对 Unpin ：

impl<Ptr: DerefMut<Target: Unpin>> DerefMut for Pin<Ptr> {
    fn deref_mut(&mut self) -> &mut Ptr::Target {
        Pin::get_mut(Pin::as_mut(self))
    }
}

对于 !Unpin 的Pin来说， &mut xxx, 获取到的是Pin结构体的可变引用而无法获取其内部指针指向的数据的可变引用

2. 针对 Unpin 类型实现 get_mut 方法

pub const fn get_mut(self) -> &'a mut T
    where
        T: Unpin,
    {
        self.__pointer
    }

如果是 !Unpin 的类型，那就只能通过 unsafe 的 get_unchecked_mut 来获取可变引用了

[cctyl]

不能理解，为什么变量在内存中会被移动？
1.移动这里指的是什么？内存地址发生了改变吗？

想不通，不管是转移所有权还是什么，内存地址不应该变化才对。以c++指针为例，只要申请了一块堆内存，只要不释放，那在整个程序运行期间都是可以访问的。
好像也找不出改变内存地址的理由，在那好好的，为什么要移动呢？

2.如果移动会导致引用失效，那我们前面所使用的引用为什么从来没考虑过这个点呢？

[minunit]

这里不是指内存地址的自动变化，代码中使用了std::mem::swap(&mut test1, &mut test2);，对比C++，应该有一个std::swap，我能想到的场景就是某些场景需要对调变量值（比如排序），如果变量很大，使用swap的方式，仅仅指对调内存地址，而不需要copy值，这样会避免不必要的消耗。

[wangzaixiang]

std::mem::swap<T>(x: &mut T, y:  &mut T) 

这里不是对调内存地址，而是值的移动。如果 sizeof(T) 为 100 字节，则是把 2个100字节的值互相复制到对方的位置上。
调用后，x, y 这两个引用地址仍然保持不变的，但其内容发生了变化。

[minunit]

这里应该是区分堆栈数据，栈上存储值，会直接复制交换，堆数据只会交换元数据，而不会对堆上的值进行复制

use std::mem;

// 100字节的栈上结构体
#[derive(Debug)]
struct SmallType([u8; 100]);

fn main() {
    let mut a = SmallType([1; 100]); // 初始值全1
    let mut b = SmallType([2; 100]); // 初始值全2

    println!("[交换前] a: {:?}, b: {:?}", a.0[0], b.0[0]);
    println!("a 地址: {:p}, b 地址: {:p}", &a, &b);

    mem::swap(&mut a, &mut b); // 交换操作

    println!("[交换后] a: {:?}, b: {:?}", a.0[0], b.0[0]); // a变为2, b变为1
    println!("a 地址: {:p}, b 地址: {:p}", &a, &b); // 地址不变
    assert_eq!(a.0[0], 2);
    assert_eq!(b.0[0], 1);


    let mut vec1 = vec![1, 2, 3]; // 堆指针地址A
    let mut vec2 = vec![4, 5, 6]; // 堆指针地址B

    println!("[交换前] vec1: {:?}, 栈地址: {:p}, 堆指针: {:p}", vec1, &vec1, vec1.as_ptr());
    println!("[交换前] vec2: {:?}, 栈地址: {:p}, 堆指针: {:p}", vec2, &vec2, vec2.as_ptr());

    mem::swap(&mut vec1, &mut vec2); // 仅交换元数据

    println!("[交换后] vec1: {:?}, 栈地址: {:p}, 堆指针: {:p}", vec1, &vec1, vec1.as_ptr()); // 堆指针变为B
    println!("[交换后] vec2: {:?}, 栈地址: {:p}, 堆指针: {:p}", vec2, &vec2, vec2.as_ptr()); // 堆指针变为A
    assert_eq!(vec1, [4, 5, 6]);
    assert_eq!(vec2, [1, 2, 3]);
}

[交换前] a: 1, b: 2
a 地址: 0x16dc19e10, b 地址: 0x16dc19ed8
[交换后] a: 2, b: 1
a 地址: 0x16dc19e10, b 地址: 0x16dc19ed8
[交换前] vec1: [1, 2, 3], 栈地址: 0x16dc1a238, 堆指针: 0x14de05fa0
[交换前] vec2: [4, 5, 6], 栈地址: 0x16dc1a250, 堆指针: 0x14de05fb0
[交换后] vec1: [4, 5, 6], 栈地址: 0x16dc1a238, 堆指针: 0x14de05fb0
[交换后] vec2: [1, 2, 3], 栈地址: 0x16dc1a250, 堆指针: 0x14de05fa0

上述示例输出结果可以看出，当堆数据使用swap时，堆指针不会发生变化，只是发生了交换

[caterpillar-1]

pin_utils 已弃用，可改用 std 的 pin! 和 pin-project

[chitandahua]

use std::mem;

#[derive(Debug)]
struct Test {
a: String,
b: *const String,
}

fn main() {
let mut t1 = Test {
a: String::from("AAA"),
b: std::ptr::null(),
};
let mut t2 = Test {
a: String::from("BBB"),
b: std::ptr::null(),
};

// 让纸条指向自己的房间
t1.b = &t1.a;
t2.b = &t2.a;

println!("========== 交换前 ==========");
println!("t1:");
println!("  a 的栈地址:     {:p}", &t1.a);
println!("  a 的堆地址:     {:p}", t1.a.as_ptr());
println!("  a 的内容:       {}", t1.a);
println!("  b 存的地址:     {:p}", t1.b);
println!("  b 指向的内容:   {}", unsafe { &*t1.b });
println!();
println!("t2:");
println!("  a 的栈地址:     {:p}", &t2.a);
println!("  a 的堆地址:     {:p}", t2.a.as_ptr());
println!("  a 的内容:       {}", t2.a);
println!("  b 存的地址:     {:p}", t2.b);
println!("  b 指向的内容:   {}", unsafe { &*t2.b });

mem::swap(&mut t1, &mut t2);

println!("\n========== 交换后 ==========");
println!("t1:");
println!("  a 的栈地址:     {:p}", &t1.a);  // 栈位置没变！
println!("  a 的堆地址:     {:p}", t1.a.as_ptr());  // 堆地址变了！
println!("  a 的内容:       {}", t1.a);
println!("  b 存的地址:     {:p}", t1.b);  
println!("  b 指向的内容:   {}", unsafe { &*t1.b });
println!();
println!("t2:");
println!("  a 的栈地址:     {:p}", &t2.a);  // 栈位置没变！
println!("  a 的堆地址:     {:p}", t2.a.as_ptr());  // 堆地址变了！
println!("  a 的内容:       {}", t2.a);
println!("  b 存的地址:     {:p}", t2.b); 
println!("  b 指向的内容:   {}", unsafe { &*t2.b });

// 额外验证：检查 b 到底指向了谁的栈
println!("\n========== 验证 ==========");
println!("t1.b 指向的是 t1.a 的栈地址吗? {}", 
         if t1.b == &t1.a { "是 ✅" } else { "否 ❌" });
println!("t1.b 指向的是 t2.a 的栈地址吗? {}", 
         if t1.b == &t2.a { "是 ✅" } else { "否 ❌" });
println!("t2.b 指向的是 t2.a 的栈地址吗? {}", 
         if t2.b == &t2.a { "是 ✅" } else { "否 ❌" });
println!("t2.b 指向的是 t1.a 的栈地址吗? {}", 
         if t2.b == &t1.a { "是 ✅" } else { "否 ❌" });

} 拿play.rust-lang.org跑一下就清楚了
========== 交换前 ==========
t1:
a 的栈地址: 0x7ffeb96d6340
a 的堆地址: 0x5e7aa0b78d60
a 的内容: AAA
b 存的地址: 0x7ffeb96d6340
b 指向的内容: AAA

t2:
a 的栈地址: 0x7ffeb96d6380
a 的堆地址: 0x5e7aa0b78d80
a 的内容: BBB
b 存的地址: 0x7ffeb96d6380
b 指向的内容: BBB

========== 交换后 ==========
t1:
a 的栈地址: 0x7ffeb96d6340
a 的堆地址: 0x5e7aa0b78d80
a 的内容: BBB
b 存的地址: 0x7ffeb96d6380
b 指向的内容: AAA

t2:
a 的栈地址: 0x7ffeb96d6380
a 的堆地址: 0x5e7aa0b78d60
a 的内容: AAA
b 存的地址: 0x7ffeb96d6340
b 指向的内容: BBB

========== 验证 ==========
t1.b 指向的是 t1.a 的栈地址吗? 否 ❌
t1.b 指向的是 t2.a 的栈地址吗? 是 ✅
t2.b 指向的是 t2.a 的栈地址吗? 否 ❌
t2.b 指向的是 t1.a 的栈地址吗? 是 ✅

栈地址指向"槽位":槽位 &t1.a 固定不动,但 swap 换的是槽里的内容。指针还指着老地方,内容却已易主 → 错位。
一句话:指针指向数据就安全,指向槽位就危险。