如何在结构体中存储自身运行线程的JoinHandle？

原代码 #

use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;

pub struct NetworkReceiver {
    terminate_flag: AtomicBool,
    join_handle: Option<thread::JoinHandle<()>>,
}

impl NetworkReceiver {
    pub fn new() -> NetworkReceiver {
        NetworkReceiver {
            terminate_flag: AtomicBool::new(false),
            join_handle: None,
        }
    }

    pub fn start(&mut self) {
        self.join_handle = Some(thread::spawn(|| self.run()));
    }

    pub fn run(&mut self) {
        while !self.terminate_flag.load(Ordering::Relaxed) {
            // ... 执行接收逻辑
        }
    }

    pub fn terminate(&mut self) {
        self.terminate_flag.store(true, Ordering::Relaxed);
    }
}

编译错误信息 #

error[E0506]: 无法赋值给`self.join_handle`，因为它已被借用
  --> src/main.rs:18:9
   |
18 |         self.join_handle = Some(thread::spawn(|| self.run()));
   |         ^^^^^^^^^^^^^^^^        ----------------------------
   |         |                       |             |  |
   |         |                       |             |  闭包中使用导致借用
   |         |                       |             `self.join_handle`在此处被借用
   |         |                       参数要求`*self`被借用至`'static`生命周期
   |         对已借用的`self.join_handle`进行赋值

error[E0521]: 借用的数据逃逸出关联函数
  --> src/main.rs:18:33
   |
17 |     pub fn start(&mut self) {
   |                  ---------
   |                  |
   |                  `self`是仅在关联函数体内有效的引用
   |                  我们称此引用的生命周期为`'1`
18 |         self.join_handle = Some(thread::spawn(|| self.run()));
   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                                 |
   |                                 `self`在此处逃逸出关联函数体
   |                                 参数要求`'1`必须长于`'static`

错误原因 #

• 'static生命周期限制：thread::spawn创建的线程会脱离当前函数上下文，Rust要求线程闭包捕获的变量必须拥有'static生命周期（即变量在整个程序运行期间都有效）。但此处闭包捕获的&mut self仅在start方法内部有效，无法满足生命周期要求。
• 借用规则冲突：尝试给self.join_handle赋值时，self已经被闭包以可变方式借用，Rust不允许同一变量同时存在可变借用和直接赋值操作。

解决方案 #

将terminate_flag包装到Arc中，让结构体和线程共享这个原子标志的所有权，线程无需持有self的引用即可独立检查终止信号。修改后的代码如下：

use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread;

pub struct NetworkReceiver {
    terminate_flag: Arc<AtomicBool>,
    join_handle: Option<thread::JoinHandle<()>>,
}

impl NetworkReceiver {
    pub fn new() -> NetworkReceiver {
        NetworkReceiver {
            terminate_flag: Arc::new(AtomicBool::new(false)),
            join_handle: None,
        }
    }

    pub fn start(&mut self) {
        // 克隆Arc，让线程持有独立引用
        let flag = Arc::clone(&self.terminate_flag);
        self.join_handle = Some(thread::spawn(move || {
            while !flag.load(Ordering::Relaxed) {
                // ... 执行接收逻辑
            }
        }));
    }

    pub fn terminate(&mut self) {
        self.terminate_flag.store(true, Ordering::Relaxed);
        // 可选：等待线程结束
        if let Some(handle) = self.join_handle.take() {
            let _ = handle.join();
        }
    }
}

关键修改说明 #

• Arc<AtomicBool>共享所有权：Arc允许多个所有者共享同一数据，线程克隆Arc后，即便结构体被修改或销毁，线程仍能安全访问终止标志。
• move闭包转移所有权：用move关键字将Arc的克隆实例转移到线程闭包中，确保闭包拥有变量所有权，满足'static生命周期要求。
• 移除self依赖：线程直接在闭包内实现循环逻辑，不再依赖结构体的可变引用，彻底解决借用冲突和生命周期问题。

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