Rust中在self方法启动的线程内调用self其他方法的实现方案

问题代码 #

use std::thread;

struct Runner {
    data: String
}

impl Runner {
    fn new(s: &str) -> Self {
        Self { data: s.to_owned() }
    }

    fn doit(&mut self) {
        // modify `self.data`
    }

    fn run(&mut self) {
        for _ in 0..4 {
            thread::spawn(move ||{
               self.doit(); 
            });
        }
    }
}

fn main() {
    let mut r = Runner::new("hello");
    r.run();
}

这段代码编译失败的核心原因是：thread::spawn要求闭包的生命周期是'static，但self是借用的，无法满足该要求；同时多次move self也会导致所有权冲突。

方案一：用Arc<Mutex<Runner>>共享整个结构体 #

这是多线程共享可变数据的标准方案，Arc提供多线程安全的引用计数，Mutex保证同一时间只有一个线程能修改数据。修改后的代码如下：

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

struct Runner {
    data: String
}

impl Runner {
    fn new(s: &str) -> Self {
        Self { data: s.to_owned() }
    }

    fn doit(&mut self) {
        // 示例修改逻辑：追加字符串
        self.data.push_str(" modified");
        println!("{}", self.data);
    }

    fn run(self) {
        // 将结构体包裹为线程安全的共享对象
        let runner = Arc::new(Mutex::new(self));
        
        for _ in 0..4 {
            // 克隆Arc，每个线程获得独立的引用计数
            let runner_clone = Arc::clone(&runner);
            thread::spawn(move || {
                // 锁定Mutex获取可变引用，unwrap简化错误处理（实际项目建议处理PoisonError）
                let mut inner = runner_clone.lock().unwrap();
                inner.doit();
            });
        }
    }
}

fn main() {
    let r = Runner::new("hello");
    r.run();
    // 主线程等待子线程完成（实际项目可通过join handle统一管理）
    thread::sleep(std::time::Duration::from_secs(1));
}

方案二：仅对data成员加锁 #

如果不需要共享整个Runner，仅需保护data字段，可以缩小锁的粒度，只给data添加Mutex：

use std::sync::Mutex;
use std::thread;

struct Runner {
    data: Mutex<String>
}

impl Runner {
    fn new(s: &str) -> Self {
        Self { data: Mutex::new(s.to_owned()) }
    }

    fn doit(&self) {
        let mut data = self.data.lock().unwrap();
        data.push_str(" modified");
        println!("{}", data);
    }

    fn run(&self) {
        for _ in 0..4 {
            let runner = self;
            thread::spawn(move || {
                runner.doit();
            });
        }
    }
}

fn main() {
    let r = Runner::new("hello");
    r.run();
    thread::sleep(std::time::Duration::from_secs(1));
}

这种方式的优势是锁的粒度更细，仅在修改data时锁定，不影响结构体其他成员的操作。

方案三：使用作用域线程（Scoped Threads） #

如果使用Rust 1.63及以上版本，可以用标准库的std::thread::scope，它允许子线程借用主线程的数据，无需满足'static生命周期，适合短期多线程任务场景：

use std::thread;

struct Runner {
    data: String
}

impl Runner {
    fn new(s: &str) -> Self {
        Self { data: s.to_owned() }
    }

    fn doit(&mut self) {
        self.data.push_str(" modified");
        println!("{}", self.data);
    }

    fn run(&mut self) {
        // 创建作用域，所有子线程会在作用域结束前自动完成
        thread::scope(|s| {
            for _ in 0..4 {
                s.spawn(|| {
                    self.doit();
                });
            }
        });
    }
}

fn main() {
    let mut r = Runner::new("hello");
    r.run();
}

该方案无需额外的同步原语，编译器会自动保证线程安全，代码更简洁。

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