如何让Rust借用检查器知晓线程会在引用失效前完成join？

我正在编写一个持有字符串引用的结构体示例，结构体定义和方法的生命周期标注本身没问题：

use std::thread;

struct Wrapper<'a> {
    s: &'a String
}

impl<'a> Wrapper<'a> {
    fn new(source_str: &'a String) -> Self {
        Self {
            s: source_str
        }
    }
}

fn main() {
    let orig_str: String = "WORD".to_string();
    {
        let w = Wrapper::new(&orig_str);
        let handle = thread::spawn(move || {
            println!("{}", w.s);
        });
        handle.join().unwrap();
    }
}

但编译时触发以下错误：

error[E0597]: `orig_str` does not live long enough
  --> src/main.rs:18:30
   |
16 |     let orig_str: String = "WORD".to_string();
   |         -------- binding `orig_str` declared here
17 |     {
18 |         let w = Wrapper::new(&orig_str);
   |                 -------------^^^^^^^^^-
   |                 |            |
   |                 |            borrowed value does not live long enough
   |                 argument requires that `orig_str` is borrowed for `'static`
...
24 | }
   | - `orig_str` dropped here while still borrowed

我清楚线程会在orig_str销毁前完成join，且orig_str生命周期长于w（移除线程后代码可正常编译），但不知道怎么让编译器认可这个安全逻辑。

原因分析 #

thread::spawn要求传入的闭包必须满足'static生命周期，因为Rust编译器无法静态验证你确实会在主线程中调用join等待子线程完成——它只能假设子线程可能存活到程序结束，因此要求闭包捕获的所有引用必须是'static的，也就是能存活整个程序运行周期。

解决方案 #

有三种贴合需求的处理方式：

1. 使用作用域线程（Rust 1.63+）

这是最匹配你需求的方案，作用域线程允许编译器静态验证子线程的生命周期不会超过作用域内的变量，不需要'static约束：

use std::thread;

struct Wrapper<'a> {
    s: &'a String
}

impl<'a> Wrapper<'a> {
    fn new(source_str: &'a String) -> Self {
        Self {
            s: source_str
        }
    }
}

fn main() {
    let orig_str: String = "WORD".to_string();
    {
        let w = Wrapper::new(&orig_str);
        thread::scope(|s| {
            let handle = s.spawn(|| {
                println!("{}", w.s);
            });
            handle.join().unwrap();
        });
    }
}

thread::scope会创建一个作用域，所有在这个作用域内创建的子线程都会在作用域结束前完成，因此编译器可以安全地允许子线程捕获作用域内的引用。

2. 转移所有权到子线程

把orig_str的所有权直接转移给子线程，完全避免引用生命周期问题：

use std::thread;

struct Wrapper {
    s: String
}

impl Wrapper {
    fn new(source_str: String) -> Self {
        Self {
            s: source_str
        }
    }
}

fn main() {
    let orig_str: String = "WORD".to_string();
    {
        let w = Wrapper::new(orig_str);
        let handle = thread::spawn(move || {
            println!("{}", w.s);
        });
        handle.join().unwrap();
    }
}

这种方式适合可以放弃主线程对orig_str所有权的场景。

3. 用Arc共享所有权

如果需要主线程和子线程同时访问orig_str，可以用Arc（原子引用计数）共享所有权，确保数据在所有引用销毁后才释放：

use std::thread;
use std::sync::Arc;

struct Wrapper {
    s: Arc<String>
}

impl Wrapper {
    fn new(source_str: Arc<String>) -> Self {
        Self {
            s: source_str
        }
    }
}

fn main() {
    let orig_str = Arc::new("WORD".to_string());
    {
        let w = Wrapper::new(orig_str.clone());
        let handle = thread::spawn(move || {
            println!("{}", w.s);
        });
        handle.join().unwrap();
    }
}

Arc的clone仅增加引用计数，不会复制底层字符串，性能开销极小。

内容的提问来源于stack exchange，提问作者los vatos locos