如何将对堆栈变量的引用传递给线程？

问：

我正在编写一个 WebSocket 服务器，其中 Web 客户端连接到与多线程计算机 AI 下棋。WebSocket 服务器希望将对象传递到 AI 代码中。该对象将通过管道将日志行从 AI 向下传递到 Web 客户端。必须包含对客户端连接的引用。LoggerLoggerLogger

我对生存期如何与线程交互感到困惑。我已经用一个由类型参数化的结构重现了这个问题。该函数尝试解开该值并记录它。Wrapperrun_thread

use std::fmt::Debug;
use std::thread;

struct Wrapper<T: Debug> {
    val: T,
}

fn run_thread<T: Debug>(wrapper: Wrapper<T>) {
    let thr = thread::spawn(move || {
        println!("{:?}", wrapper.val);
    });

    thr.join();
}

fn main() {
    run_thread(Wrapper::<i32> { val: -1 });
}

参数存在于堆栈上，其生存期不会超过 的堆栈帧，即使线程将在堆栈帧结束之前加入。我可以从堆栈中复制该值：wrapperrun_thread

use std::fmt::Debug;
use std::thread;

struct Wrapper<T: Debug + Send> {
    val: T,
}

fn run_thread<T: Debug + Send + 'static>(wrapper: Wrapper<T>) {
    let thr = thread::spawn(move || {
        println!("{:?}", wrapper.val);
    });

    thr.join();
}

fn main() {
    run_thread(Wrapper::<i32> { val: -1 });
}

如果是对我不想复制的大对象的引用，这将不起作用：T

use std::fmt::Debug;
use std::thread;

struct Wrapper<T: Debug + Send> {
    val: T,
}

fn run_thread<T: Debug + Send + 'static>(wrapper: Wrapper<T>) {
    let thr = thread::spawn(move || {
        println!("{:?}", wrapper.val);
    });

    thr.join();
}

fn main() {
    let mut v = Vec::new();
    for i in 0..1000 {
        v.push(i);
    }

    run_thread(Wrapper { val: &v });
}

其结果是：

error: `v` does not live long enough
  --> src/main.rs:22:32
   |
22 |     run_thread(Wrapper { val: &v });
   |                                ^ does not live long enough
23 | }
   | - borrowed value only lives until here
   |
   = note: borrowed value must be valid for the static lifetime...

我能想到的唯一解决方案是使用 .Arc

use std::fmt::Debug;
use std::sync::Arc;
use std::thread;

struct Wrapper<T: Debug + Send + Sync + 'static> {
    arc_val: Arc<T>,
}

fn run_thread<T: Debug + Send + Sync + 'static>(wrapper: &Wrapper<T>) {
    let arc_val = wrapper.arc_val.clone();
    let thr = thread::spawn(move || {
        println!("{:?}", *arc_val);
    });

    thr.join();
}

fn main() {
    let mut v = Vec::new();
    for i in 0..1000 {
        v.push(i);
    }

    let w = Wrapper { arc_val: Arc::new(v) };
    run_thread(&w);

    println!("{}", (*w.arc_val)[0]);
}

在我的实际程序中，似乎 和 connection 对象都必须放在包装器中。当代码并行化的库内部时，客户端需要将连接装箱，这似乎很烦人。这尤其令人讨厌，因为连接的生存期保证大于工作线程的生存期。LoggerArcArc

我错过了什么吗？