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]

这个终于说清楚了。。。

[horsefaced]

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

[fadedzipper]

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

[taiiiyang]

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

[stolen-programmer]

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

[ranqiwei]

已经麻了，这节。

[stolen-programmer]

Pin唯一的作用就是在实现了!Unpin的情况下阻止你调用get_mut
别想了 兄弟们

[TsGanT]

好像有点懂了，总而言之，Pin的作用就是保证被其包裹的指针所指向的值不能被 改动 ，其实我觉得作者文中说的 移动 多少有点让人产生误解，移 这个字总有种挪动的感觉，但其实本质就是 改动 ，移动 就是 改动 的一种，就是和之前变得不一样了，说白了就是 变了 ；
那Pin防止其包裹指针所指向的内容不会 变了 的实现就很简单了 那就是你不能获取其包裹指针的 可变引用 ，这样以来自然就不能变了；
至于说什么时候使用，这个也不用纠结，你觉得某个被引用的内容，如果不希望被改变，那你就用，Pin说白了 起到一个防止的作用；但你觉得无所谓，比如自引用 我指向的值可以被改变，那你就不用，unsafe + 裸指针改就完事了；
最后，由于你能Pin住的 其实只有堆上的内容，因为保存在栈上的变量，本身也不需要靠指针来传递值，直接深拷贝就OK了，因此你Pin不了栈上的变量，即 基本变量；

[TsGanT]

我觉得 再直白点 就是rust总得给你提供一种 保证指针指向的值不能被改动的 机制吧？那否则就剩下了所有的指针指向的对象 都可以被改变 这一种case，只有这一种倒也不是不行 那也可以在不希望被改动的情况下 自己保证写代码的时候不去改他 但这不就留下了隐患，那就是这种保证变成了纯代码层面的，而rust只是在为那些 明确知道自己的内容不希望被改变的case 加了一层 编译层面的保障，使得代码更加的安全 我觉得rust做的对！

[TsGanT]

我好像又悟了 不确定对不对 分享出来大家也可以一起探讨，所谓语言中的某种特性 其实都是围绕功能设计的，一个语言特性难理解，比如vtable也好 Pin也好 所谓的Future也好，难理解的原因其实还是现实场景中的为什么需要这个功能难理解；以Pin为例，他难理解是因为本身他也可有可无，你指向的内容如果允许被改变，那就不需要Pin，甚至不能被改变，你不从编译的角度保证，你从代码的角度保证，也行；只是rust提供Pin出来 从编译层面 更严格的提供了不可改变的 能力而已；我相信其实所有的科目都是这样的，为什么要方向盘，这个很好理解，因为开车我总要控制方向吧，所以由于场景大家都耳熟能详 都好理解，因此汽车上存在方向盘，也就好理解了，Pin其实也就是“汽车”上面，一个起到某个作用的实现而已，和一个方向盘没什么区别；其他的 哪怕做一个项目，其中的一个功能 一个开关，他好不好理解，也是看他针对要解决的那个场景 好不好理解而已；我甚至觉得换一个学科，也都是这样的，经济学那么多名词，工具 我觉得也就是一种对于 现实场景的抽象解决 而存在的一些东西而已。

[mcbbsandnz]

介绍为何需要pin的图是否使用该博客里的"Self-reference is unsafe"段落里的图会更好?感觉现在的解释有些不清晰
https://blog.cloudflare.com/pin-and-unpin-in-rust/

[HC-miss]

完全看不懂了:(

[CopilotAccount2]

    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 这样的代码