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

我正在编写一个 WebSocket 服务器，其中 Web 客户端连接以与多线程计算机 AI 下棋。 WebSocket 服务器想要传递一个Logger对象到 AI 代码中。这Logger对象会将日志行从 AI 传送到 Web 客户端。这Logger必须包含对客户端连接的引用。

我对生命周期如何与线程交互感到困惑。我用一个重现了这个问题Wrapper由类型参数化的结构。这run_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 });
}

The wrapper参数存在于堆栈中，并且其生命周期不会超过run_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]);
}

在我的真实程序中，似乎两者Logger并且连接对象必须放置在Arc包装纸。客户端需要将连接装箱似乎很烦人Arc当代码在库内部时是并行化的。这尤其令人烦恼，因为连接的生命周期保证大于工作线程的生命周期。

我错过了什么吗？

标准库中的基本线程支持允许创建的线程比创建它们的线程寿命更长；这是好事！但是，如果您将对堆栈分配的变量的引用传递给这些线程之一，则无法保证该变量在线程执行时仍然有效。在其他语言中，这将允许线程访问无效内存，从而产生一堆内存安全问题。

一种解决方案是作用域线程— 保证在父线程退出之前退出的线程。这些可以确保父线程中的堆栈变量在线程的整个持续时间内可用。

生锈 1.63

std::thread::scope https://doc.rust-lang.org/beta/std/thread/fn.scope.html时隔 7 年之后回归稳定的 Rust (removal https://github.com/rust-lang/rust/commit/6399bb425b3a82111cd554737f194c95b8f6bad5, return https://github.com/rust-lang/rust/issues/93203).

use std::{thread, time::Duration};

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];

    thread::scope(|scope| {
        for e in &mut vec {
            scope.spawn(move || {
                thread::sleep(Duration::from_secs(1));
                *e += 1;
            });
        }
    });

    println!("{:?}", vec);
}

早期的 Rust 版本或当您需要更多控制时

横梁

我们不仅限于标准库；作用域线程的流行板条箱是横梁 https://crates.io/crates/crossbeam:

use crossbeam; // 0.6.0
use std::{thread, time::Duration};

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];

    crossbeam::scope(|scope| {
        for e in &mut vec {
            scope.spawn(move |_| {
                thread::sleep(Duration::from_secs(1));
                *e += 1;
            });
        }
    })
    .expect("A child thread panicked");

    println!("{:?}", vec);
}

rayon

还有像这样的箱子rayon https://crates.io/crates/rayon它抽象了“线程”的低级细节，但允许您实现您的目标：

use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator}; // 1.0.3
use std::{thread, time::Duration};

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];

    vec.par_iter_mut().for_each(|e| {
        thread::sleep(Duration::from_secs(1));
        *e += 1;
    });

    println!("{:?}", vec);
}

关于示例

每个示例都会生成多个线程，并在没有锁定的情况下就地改变本地向量Arc，并且没有克隆。请注意，突变有一个sleep调用以帮助验证调用是否并行发生。

您可以扩展示例以共享对实现的任何类型的引用Sync https://doc.rust-lang.org/std/marker/trait.Sync.html， 比如一个Mutex or an Atomic*。然而，使用这些会引入锁定。

客户端需要将连接装箱Arc当代码在库内部时是并行化的

也许你可以更好地隐藏你的并行性？您可以接受记录器，然后将其包装在一个Arc / Mutex在将其交给您的线程之前？