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又涉及到自引用。

[jiyuan0125]

按照我的理解，要求使用Unpin的Future的函数，是要避免消费掉async产生的Future，比如在一个处在loop中的select!，每次消费的应该是Future的指针，如果消费掉了Future, 下次循环时将会报错。
文中的execute_unpin_future函数，是能在loop中反复运行的函数。根据参数的定义，他无法直接消费async产生的Future，因为async产生的Future带有!Unpin。我们可以使用Pin<Box>，或Pin<&mut Future> 作为参数，这两种参数即是Unpin，也是Future，就相当于只消费了Future的指针，使得loop能够正常运行。Pin<Box>是Unpin的，因为它内部不含有PhantomPinned。Pin<Box>是Future，这一点我们可以从Pin的源码中得知，Pin对P: ops::DerefMut<Target: Future>实现了Future trait。

#[stable(feature = "futures_api", since = "1.36.0")]
impl<P> Future for Pin<P>
where
    P: ops::DerefMut<Target: Future>,
{
    type Output = <<P as ops::Deref>::Target as Future>::Output;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        <P::Target as Future>::poll(self.as_deref_mut(), cx)
    }
}

[jiyuan0125]

我在上一条回复里的Pin打错了，是Pin<Box>。

[jiyuan0125]

Pin< Box > 是 Pin < Box < Future > >

[jiyuan0125]

好吧，我再一次理解错了，有疑问的同学试试这篇文章。
https://fasterthanli.me/articles/pin-and-suffering

[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]

已经麻了，这节。

[runzhi214]

关于最后一节Future变为UnPin：poll方法要求Pin<&mut Fut>。Future变为UnPin之后就不能使用poll了呀？
那它还能作为Future使用吗？

[runzhi214]

我自己查到了，UnPin也可以，因为UnPin也给Pin实现了PollFn。大意就是Poll的对象必须要么是Pin要么是UnPin，而UnPin表示即使移动了我也不在乎。

/// 官方库
impl<F> Unpin for PollFn<F>
where
    F: Unpin,

[runzhi214]

关于1.64版本给UnPin的开的后门可以看这个知乎文章

[tjw123hh]

来自ChatGPT：
在Rust中，Pin类型用于确保在内存中固定某个值，以防止它被移动。它是为了支持异步编程而引入的。

在通常情况下，Rust的所有权系统和借用检查器能够确保引用的有效性。通过这些机制，Rust确保在编译时检查引用是否有效，以避免悬垂引用或竞争条件等错误。

然而，在异步编程中，可能会出现一些特殊情况，这时需要使用Pin来处理。异步编程中的Future类型通常会涉及在异步执行期间保存对某个值的引用，但异步操作可能会移动这个值。为了确保在异步执行期间引用的有效性，需要将值固定在内存中，以防止其被移动。这是Pin类型的作用所在。

Pin类型可以将一个值固定在内存中，以确保在异步上下文中引用的有效性。通过将值固定，Rust编译器可以在编译时检查移动操作，并防止对固定值的非法移动。

需要注意的是，Pin仅仅是为了异步编程引入的特殊情况下使用的，并不是在所有情况下都需要使用。在大多数情况下，Rust的所有权系统和借用检查器已经足够确保引用的有效性。只有在异步编程中需要在异步执行期间保持引用有效时才需要使用Pin。

[tjw123hh]

（建议看看https://zhuanlan.zhihu.com/p/67803708）

[wuhaiji]

从某些角度来看，Box、Rc、Arc等智能指针确实都提供了类似于Pin的功能：它们都保证了对象在内存中的位置不会发生改变（只有智能指针本身可以移动）。

然而，将Pin定义为一个trait并让这些智能指针去实现它可能会引入额外的复杂性和可能的混乱。例如，Rc和Arc是允许多个共享所有权的，当最后一个指向该数据的智能指针被丢弃时，数据会被自动清理。但如果我们把Rc或Arc用在需要固定内存位置的场景（比如异步编程），可能会出现问题。因为此时可能还有其他地方的代码保留着对原始数据的引用，而清理操作会导致悬挂引用。

此外，Pin更多的是一种约束，它表示对象应该是被"固定"的，即不能被移动。它不只适用于Box、Rc和Arc，也适用于任何实现了Deref和DerefMut trait的类型，包括裸指针*mut T和引用&mut T。因此，将Pin定义为一个通用的包装器结构体是有意义的。gpt回答的，不知道有没有道理 🐶

[cj495840252]

能看懂，不会写

[stolen-programmer]

Pin不过是个在其生命周期内无法通过Pin调用get_mut来获取一个可变引用的手段
什么定住简直是搞笑

当你的函数参数是Pin 你又无法通过参数拿到可变引用 自然无法移动

[TsGanT]

最后一段完全没有看懂呀 将固定住的 Future 变为 Unpin，尤其是这一句

固定后获得的 Pin<Box> 和 Pin<&mut T> 既可以用于 Future ，又会自动实现 Unpin。

明明是 Pin<Box<T>> 这不是给Pin住了 那为啥又自动实现了 Unpin ？那所以 Pin<Box> 他到底是属于Unpin 还是 !Unpin？

[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管

[vince-1998]

emo了