rust - 这个作用域线程代码可以更改为使用 `FnOnce()` 而不是 `Box` 吗？

Question

我有以下代码在 Rust 中实现作用域线程——也就是说，能够生成线程并安全地访问堆栈上的变量。以下大部分代码取自 crossbeam , 也有一点灵感来自 scoped_threadpool .

use std::thread;
use std::thread::JoinHandle;
use std::collections::LinkedList;
use std::marker::PhantomData;
use std::boxed::Box;

pub struct Scope<'a> {
    join_handles: LinkedList<JoinHandle<()>>,
    _marker: PhantomData<::std::cell::Cell<&'a mut ()>>
}

impl<'a> Scope<'a> {
    pub fn spawn<F>(&mut self, f: F) where F: FnOnce() + Send + 'a {
        // Could this be done without using a Box?
        let closure: Box<FnBox + Send + 'a> = Box::new(f);
        let closure: Box<FnBox + Send + 'static> = unsafe{
            std::mem::transmute(closure)
        };
        let join_handle = thread::spawn(move || closure.call_box());
        self.join_handles.push_back(join_handle);
    }
}

pub fn scope<'a, F, R>(f: F) -> R where F: FnOnce(&mut Scope<'a>) ->     R {
    let mut scope = Scope {
        join_handles: LinkedList::new(),
        _marker: PhantomData
    };
    let ret = f(&mut scope);
    for join_handle in scope.join_handles {
        join_handle.join().unwrap();
    }
    ret
}

trait FnBox {
    fn call_box(self: Box<Self>);
}

impl<F: FnOnce()> FnBox for F {
    fn call_box(self: Box<Self>) { (*self)() }
}

// Example usage:

// let mut foo = 0;
// scope(|mut scope| {
//     scope.spawn(|| {
//         foo = 1;
//     });
// });
// assert!(foo == 1);

是否可以更改 spawn 函数，使 f 不被放置在 Box 中，以避免额外的堆分配？如果不是，为什么需要使用 Box？

Answer 1

据我所知，从 Rust 1.12 开始，这是不可能的。我们必须将 f 转换为另一种大小相同的类型，以遵守 'static 绑定(bind)。最直接的方法是将其转换为与 F 大小相同的字节数组，但这是不可能的，因为我们不能使用 size_of。在常量表达式中(就像我们在 C++ 中使用 sizeof 一样)。

我们可以通过分配一个独立于 F 的固定大小的数组来解决这个问题，如果 F 太大则 panic 或回退到使用 盒子。

impl<'a> Scope<'a> {
    pub fn spawn<F>(&mut self, f: F) where F: FnOnce() + Send + 'a {
        assert!(std::mem::size_of::<F>() <= 256);
        let mut x: [u8; 256] = [0; 256];
        unsafe { std::ptr::write(&mut x as *mut _ as *mut F, f); }
        let join_handle = thread::spawn(move || {
            let f: F = unsafe { std::mem::transmute_copy(&x) };
            f()
        });
        self.join_handles.push_back(join_handle);
    }
}