Rust 如何在没有作用域的情况下使用RwLocks？

我试图在不使用作用域线程的情况下在多个线程之间共享一个线程，但我不知道如何获得正确的生命周期。我假设这是可能的（否则RwLocks有什么意义？），但我找不到任何例子

这里是一个玩具的例子，我正在努力完成。如有任何建议，将不胜感激。

---

&mut

将引用发送到非作用域线程是不安全的，因为该线程在被引用的数据被解除分配后仍可能运行。此外，在

helper

返回后，主线程仍然可以变异

stuff

，派生线程也可以间接变异

stuff

，这在Rust中是不允许的（一个变量只能有一个可变别名）

相反，

rBlock

应该拥有数据，而不是借用数据。这意味着

helper

应该接收

Stuff

而不是

&mut Stuff

use std::sync::{Arc, RwLock};
use std::thread;

struct Stuff {
    x: i32
}

fn main() {
    let mut stuff = Stuff{x: 5};
    helper(stuff);
    println!("done");
}

fn helper(stuff: Stuff){
    let rwlock = RwLock::new(stuff);
    let arc = Arc::new(rwlock);
    let local_arc = arc.clone();
    for _ in 0..10{
        let my_rwlock = arc.clone();
        thread::spawn(move || {
            let reader = my_rwlock.read().unwrap();
            // do some stuff
        });
    }
    let mut writer = local_arc.write().unwrap();
    writer.x += 1;
}

use std::sync::{Arc, RwLock};
use std::thread;

struct Stuff {
    x: i32
}

fn main() {
    let mut stuff = Stuff{x: 5};
    helper(stuff);
    println!("done");
}

fn helper(stuff: Stuff){
    let rwlock = RwLock::new(stuff);
    let arc = Arc::new(rwlock);
    let local_arc = arc.clone();
    for _ in 0..10{
        let my_rwlock = arc.clone();
        thread::spawn(move || {
            let reader = my_rwlock.read().unwrap();
            // do some stuff
        });
    }
    let mut writer = local_arc.write().unwrap();
    writer.x += 1;
}