advance/smart-pointer/drop

[giscus[bot]]

advance/smart-pointer/drop

https://course.rs/advance/smart-pointer/drop.html

[CelestialMelody]

rust是如何做到不会在手动drop后（利用可变引用），自动drop（所有权转移）时，
不会再次drop已经手动drop的资源；即如何避免二次析构的？

[Mota-Link]

手动调用时，所有权通过参数传入drop()，然后在drop()方法结束时(离开作用域)，调用Drop()::drop()释放掉形参。

也就是说，并不是mem::drop()导致的释放，而是在mem::drop()结束时自动释放。

[bczhc]

哦哦，我还看了下mem::drop()方法呢，看到里面一个空实现，没有说“内部实现”之类的注释。原来就只是带走所有权然后离开它自己的作用域来drop，这么妙

[tjw123hh]

就是把所有权带走不传出来，然后就自动drop了（）

[tjw123hh]

而假如实现了 Copy trait 就不起作用了

[araraloren]

我记得现在是用额外的变量记录一下，以前的时候实现是为实现了Drop的类型隐藏了一个flag

[idlercloud]

关于 Copy 和 Drop 互斥这一点，我个人觉得其实不止难以预测这一点。可以参考一下 StackOverflow 的回答：Why does Rust not allow the copy and drop traits on one type?

[fadedzipper]

确实，更重要的是内存安全（资源正确释放）方面的考虑。
copy可以理解为栈内存的简单复制，通常意义上的浅拷贝，trivial copy。
简单举例来说，有一个结构体只包含一个指针，这个指针指向分配出来的堆内存。
它实现了Drop，作用是释放堆上的内存（类似于c++里面的析构函数）。编译器做的工作是在栈上分配的类或者结构体，在离开作用域时自动插入析构的函数。

copy会把这个指针复制一遍，这时候就有两个结构体在栈上。
结构体离开了作用域，会调用drop，这个时候就会调用两遍析构，但是结构体管理的实际资源（堆上的一段内存）只有一个，此时资源就被释放两遍了。这是一种内存错误。

解决方法就是

1. 不仅仅复制栈上的结构，我复制这个结构体的时候把资源也复制一份。也就是clone trait。
2. 使用智能指针，给资源做一个引用计数，结构体作为引用计数和资源的控制结构。每次出作用域的时候，就检查一遍引用计数，判断此时可以不可以释放。
3. 禁止复制，也就是move语义，资源的控制结构只存在一个，这个控制结构拥有所有权。move语义的赋值其实也是仅仅复制栈上的结构，但是编译器帮我记住现有栈上有效的结构到底是哪一个。我要是用错了，就报错。
4. 有gc的，就用gc来释放。

[Satar07]

感谢你提供了很好的扩展资料！

我的理解是如果drop需要自己来写的时候，这个时候一定是涉及到管理堆的内存了。而copy是允许浅拷贝的标记。
rust不允许这种用到堆内存又允许浅拷贝的危险结构存在，所以copy和drop在rust中是互斥的

[KrvyFT]

基本類型是同時實現了 Copy 和 Drop 嗎, 爲什麼它們可以 ?

[idlercloud]

考虑 usize 的实现 trait 列表，只看到了 Copy https://doc.rust-lang.org/std/primitive.usize.html#impl-Copy。
所以基本类型应该都是只实现 Copy 的
Drop 主要是给一些 RAII 的东西用的，它们往往需要在析构的时候做一些额外的操作，像是释放堆上的数据之类的。
而基本类型并不需要什么额外的操作。

[wreqwewqe]

程序结束的时候，执行drop的时候，这个hastwodrops的struct清理了内存空间，存在他里面的字段肯定也被清理，为什么还能调用他里面字段的drop方法

[idlercloud]

顺序大概是：HasTwoDrops 开始析构->调用其自定义的 drop 函数->递归执行字段的析构->完成析构。
字段的析构应该是在自定义的 drop 函数调用之后。
参考 https://doc.rust-lang.org/std/ops/trait.Drop.html#

[WenqingZong]

drop之所以是&mut self，是为了在清理时可以方便的修改实例内部的信息。明白了。

[xgfone]

在非主线程中，定义了一个实现 Drop 特征的对象变量（它内部申请了堆内存），原本是想在变量到达作用域结尾时被释放的，结果在此之前发生了 panic，此时不会调用 drop 释放堆内存，那是否就意味着内存泄露了呢？

[WenqingZong]

出于好奇心写了个测试：

use std::thread::spawn;

#[derive(Debug)]
struct A {
    _strings: Vec<String>,
}

impl A {
    fn new(init_string: &str) -> Self {
        let strings = vec![init_string.to_owned()];
        Self {
            _strings: strings
        }
    }
}

impl Drop for A {
    fn drop(&mut self) {
        println!("dropped");
    }
}

fn main() {
    let handle = spawn(move || {
        let a = A::new("hello");
        panic!("Oh no!");
        println!("{:?}", &a);
    });
    handle.join().unwrap();
}

运行结果：

thread '<unnamed>' panicked at 'Oh no!', src/main.rs:26:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
dropped
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Any { .. }', src/main.rs:29:19

所以，即使子线程panic了，变量也会被drop掉。
Rust牛逼。。。。

以及，我隐约记得当主线程退出时，OS自己也会检查下是否所有资源都被释放了？

[xgfone]

当主线程退出时，意味着进程结束，此时操作系统会回收与该进程有关的所有资源，所以，即使程序退出时不回收资源，操作系统也会回收。

[xgfone]

我也测试了一下，如果 struct 中没有任何域字段（如 type Foo{}），drop 方法不会被调用；如果给 Foo 随意添加一个任何类型的字段（如 u8），drop 方法就会被调用。

[WenqingZong]

我也测试了一下，如果 struct 中没有任何域字段（如 type Foo{}），drop 方法不会被调用；如果给 Foo 随意添加一个任何类型的字段（如 u8），drop 方法就会被调用。

学到了，谢谢

[duanyuluo]

panic的时候必须清理栈内存。因为panic是按照栈的顺序逆向执行的，栈顶如果不清理，栈底可能会捕获panic，然后程序继续运行，这就会导致mem leak。不要误解panic就是process或thread就一定退出了。

[fadedzipper]

stack unwrap。栈展开。发生异常时，在栈上的变量都会运行析构。直到异常被捕获。 主要目的是为了异常安全，分配的资源都释放掉。 cpp也有这技术。

…

---- 回复的原邮件 ---- | 发件人 | Wenqing ***@***.***> | | 日期 | 2023年06月05日 23:55 | | 收件人 | ***@***.***> | | 抄送至 | ***@***.***>***@***.***> | | 主题 | Re: [sunface/rust-course] advance/smart-pointer/drop (Discussion #749) | 出于好奇心写了个测试： use std::thread::spawn;#[derive(Debug)]structA{_strings:Vec<String>,}implA{fnnew(init_string:&str) -> Self{let strings = vec![init_string.to_owned()];Self{_strings: strings }}}implDropforA{fndrop(&mutself){println!("dropped");}}fnmain(){let handle = spawn(move || {let a = A::new("hello");panic!("Oh no!");println!("{:?}", &a);}); handle.join().unwrap();} 运行结果： thread '<unnamed>' panicked at 'Oh no!', src/main.rs:26:9 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace dropped thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Any { .. }', src/main.rs:29:19 所以，即使子线程panic了，变量也会被drop掉。 Rust牛逼。。。。 以及，我隐约记得当主线程退出时，OS自己也会检查下时候所有资源都被释放了？ — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[liaojiawei666]

大佬们帮忙看下，这段代码为什么会报错啊？

struct HasDrop1;
struct HasDrop2;

impl Drop for HasDrop1{
    fn drop(&mut self){
        println!("Dropping HasDrop1")
    }
}
//如果移除下面的语句就不会报错
//--------------------------
impl Drop for HasDrop2{
    fn drop(&mut self){
        println!("Dropping HasDrop2")
    }
}
//---------------------------

struct HasTwoDrops{
    one:HasDrop1,
    two:HasDrop2
}

impl Drop for HasTwoDrops {
    fn drop(&mut self) {
        println!("Dropping HasTwoDrops!");
    }
}


fn main(){
    let one=HasDrop1;
    let two;
    {
        let _x=HasTwoDrops{
            one,
            two:HasDrop2,
      
        };
        two=_x.two;
    }
  
    println!("Running! ");
    let z=two;
}

报错信息：

error[E0509]: cannot move out of type `HasTwoDrops`, which implements the `Drop` trait
  --> src\main.rs:37:13
   |
37 |         two=_x.two;
   |             ^^^^^^
   |             |
   |             cannot move out of here
   |             move occurs because `_x.two` has type `HasDrop2`, which does not implement the `Copy` trait

但是如果移除下面代码就不报错了

impl Drop for HasTwoDrops {
    fn drop(&mut self) {
        println!("Dropping HasTwoDrops!");
    }
}

[liaojiawei666]

我发现如果一个结构体实现了Drop这个trait，那么这个结构体的所有字段就没法被移动出来了，但是不是说大多数类型都默认实现了Drop这个trait吗？下面这个也会报错：

struct Bar;
struct Foo{
    bar:Bar
}

impl Drop for Foo {
    fn drop(&mut self){
        println!("drop foo!");
    }
}


fn main(){
    let foo=Foo{bar:Bar};
    let bar=foo.bar;
}

[carzpurzkey]

🤔是不是编译器怕你在 drop 里用到成员，就索性不让你移出来呢

[yizhixiaowutu]

let bar=foo.bar;

转移了所有权，会导致foo中的bar字段无法正确访问并释放掉，drop 的时候可能造成资源泄露。

[jinmingzhuo]

drop函数跟真正释放内存的函数是什么关系呢？如果我在drop函数里只写了print函数，对象的内存会被释放吗？

[araraloren]

只要你转移了所有权给一个函数，那函数结束的时候就会自动drop

[yuliang0225]

Drop：他来了，然后带走了一切。

[lgln0]

实现Drop特征需要可变引用，但如果对象本身是不可变的，如何有可变引用？（hh..）

[Endermanbugzjfc]

所有权会交给 std::mem::drop
这时可变性的决定也交给了它

[zcjie1]

所以不可变对象不能用Drop特征里的drop函数，只能用std::mem::drop函数