Rust从关联函数启动线程时遭遇E0521借用逃逸错误求助

我在编写run方法启动新线程并保存线程句柄到结构体属性时，遇到了以下编译器错误：

error[E0521]: borrowed data escapes outside of method                                                                                                                                                                                                                                                               --> src\server\dispatcher.rs:33:27
   |
28 |       pub fn run(&mut self) {
   |                  ---------
   |                  |
   |                  `self` is a reference that is only valid in the method body
   |                  let's call the lifetime of this reference `'1`
...
33 |           let main_thread = thread::spawn(move || loop {
   |  ___________________________^
34 | |             match rx.try_recv() {
35 | |                 Ok(_) | Err(TryRecvError::Disconnected) => {
36 | |                     break;
...  |
43 | |             }
44 | |         });
   | |          ^
   | |          |
   | |__________`self` escapes the method body here
   |            argument requires that `'1` must outlive `'static`

我的代码如下：

pub fn run(&mut self) {
    let (tx, rx) = mpsc::channel::<()>();

    let packets = Arc::new(Mutex::new((&self.packets)));

    let main_thread = thread::spawn(move || loop {
        match rx.try_recv() {
            Ok(_) | Err(TryRecvError::Disconnected) => {
                break;
            }
            Err(TryRecvError::Empty) => {
                let inside = packets.clone();

                let qwe = packets.lock().unwrap();
            }
        }
    });

    self.main_thread = Some(main_thread);
}

问题原因 #

错误核心在于Arc::new(Mutex::new((&self.packets)))这行代码：你创建了一个包裹self.packets引用的Arc<Mutex<&T>>，但thread::spawn要求闭包捕获的变量必须拥有'static生命周期（即变量能存活到程序结束，不能依赖方法内的临时引用）。而&self.packets的生命周期仅局限于run方法内部，方法结束后引用失效，线程却仍持有它，因此触发编译器报错。

解决方案 #

1. 修改结构体字段为可共享的Arc<Mutex<T>>（推荐） #

如果结构体设计允许，最合理的方式是将packets字段直接定义为Arc<Mutex<YourPacketType>>，这样在run方法中只需克隆Arc即可共享所有权，无需包裹引用：

首先调整结构体定义：

use std::sync::{Arc, Mutex};
use std::thread;
use std::sync::mpsc;
use std::sync::mpsc::TryRecvError;

struct YourStruct {
    packets: Arc<Mutex<Vec<u8>>>, // 替换为你的实际数据包类型
    main_thread: Option<thread::JoinHandle<()>>,
}

然后修改run方法：

impl YourStruct {
    pub fn run(&mut self) {
        let (tx, rx) = mpsc::channel::<()>();

        // 直接克隆Arc，共享所有权
        let packets = self.packets.clone();

        let main_thread = thread::spawn(move || loop {
            match rx.try_recv() {
                Ok(_) | Err(TryRecvError::Disconnected) => {
                    break;
                }
                Err(TryRecvError::Empty) => {
                    let qwe = packets.lock().unwrap();
                    // 在这里对数据包进行操作，比如遍历、处理等
                }
            }
        });

        self.main_thread = Some(main_thread);
    }
}

2. 转移packets的所有权（仅适用于结构体不再需要该字段的场景） #

如果调用run方法后，结构体不再需要访问packets，可以通过std::mem::take转移其所有权到线程中：

pub fn run(&mut self) {
    let (tx, rx) = mpsc::channel::<()>();

    // 转移packets的所有权，原字段会被置为默认值（比如空Vec）
    let packets = Arc::new(Mutex::new(std::mem::take(&mut self.packets)));

    let main_thread = thread::spawn(move || loop {
        match rx.try_recv() {
            Ok(_) | Err(TryRecvError::Disconnected) => {
                break;
            }
            Err(TryRecvError::Empty) => {
                let qwe = packets.lock().unwrap();
                // 操作数据包
            }
        }
    });

    self.main_thread = Some(main_thread);
}

这种方式会清空self.packets的原有数据，后续结构体无法再访问该字段，仅适合特定业务场景。

内容的提问来源于stack exchange，提问作者geo10