Parallel processing 对于接受一个函数并返回另一个函数（该函数向线程返回句柄）的函数，类型签名应该是什么？

我正在尝试编写一个函数

parallelize

，它将函数

B

作为参数，并返回函数

C

，其中

C

返回运行

B

的线程的句柄。我理解这可能是笨拙或可笑的；这主要是一个学习项目。更高级别的目标是在迭代器上实现并行映射函数，其中列表的每个元素将映射到不同的线程中（或者最终可能通过线程池）。我很快就意识到我有点不知所措。根据我所描述的，并行化的类型应该是什么？

让我们一步一步地看一下：

函数

并行化

是的，这是一个函数

参数a函数B

我假设您希望函数能够返回某些内容，因此我将使用泛型类型

R

fn parallelize<B, R>(function: B)
where
    B: FnOnce() -> R,
{
    unimplemented!()
}

fn并行化（功能：B）
哪里
B:FnOnce（）->R，
{
未执行！（）
}

返回一个函数C

哦。你。这意味着我们将返回一个装箱的trait对象

fn并行化（函数：B）->Box
哪里
B:FnOnce（）->R，
{
未执行！（）
}

其中C向运行B的线程返回句柄

使用std:：thread:：JoinHandle；
fn并行化（功能：B）->Box JoinHandle>
哪里
B:FnOnce（）->R，
{
未执行！（）
}

这是你的签名。都做完了

当然，还有很多事情要做。例如，您没有说明线程实际应该何时启动。这意味着我可以选择，而且我选择了最简单的方式——当调用方请求句柄时，线程就开始了

use std::thread::{self, JoinHandle};

fn parallelize<B, R>(function: B) -> Box<FnOnce() -> JoinHandle<R>>
where
    B: Send + FnOnce() -> R + 'static,
    R: Send + 'static,
{
    Box::new(|| thread::spawn(function))
}

使用std:：thread:：{self，JoinHandle}；
fn并行化（功能：B）->Box JoinHandle>
哪里
B:Send+FnOnce（）->R+'静态，
R:发送+'静态，
{
框：：新建（| |线程：：生成（函数））
}

我想你也可以马上开始：

use std::thread::{self, JoinHandle};

fn parallelize<B, R>(function: B) -> Box<FnOnce() -> JoinHandle<R>>
where
    B: Send + FnOnce() -> R + 'static,
    R: Send + 'static,
{
    let handle = thread::spawn(function);
    Box::new(|| handle)
}

使用std:：thread:：{self，JoinHandle}；
fn并行化（功能：B）->Box JoinHandle>
哪里
B:Send+FnOnce（）->R+'静态，
R:发送+'静态，
{
让handle=thread:：spawn（函数）；
盒子：新的（| |把手）
}

我不知道你为什么要做第二个；在这种情况下，您最好直接返回句柄。如果您这样做了，那么您最好直接调用

thread:：spawn

哦，我想我不能从你身边溜走，是吗？调用

thread:：spawn

时，必须确保传递给它的任何内容在线程退出（因此

静态

）之前都不会停止有效，并且可以在线程之间安全传输（因此

发送

）

更高级别的目标是在迭代器上实现并行映射函数

它存在并被称为

---

另见：

---

让我们一步一步地看一遍：

函数

并行化

是的，这是一个函数

参数a函数B

我假设您希望函数能够返回某些内容，因此我将使用泛型类型

R

fn parallelize<B, R>(function: B)
where
    B: FnOnce() -> R,
{
    unimplemented!()
}

fn并行化（功能：B）
哪里
B:FnOnce（）->R，
{
未执行！（）
}

返回一个函数C

哦。你。这意味着我们将返回一个装箱的trait对象

fn并行化（函数：B）->Box
哪里
B:FnOnce（）->R，
{
未执行！（）
}

其中C向运行B的线程返回句柄

使用std:：thread:：JoinHandle；
fn并行化（功能：B）->Box JoinHandle>
哪里
B:FnOnce（）->R，
{
未执行！（）
}

这是你的签名。都做完了

当然，还有很多事情要做。例如，您没有说明线程实际应该何时启动。这意味着我可以选择，而且我选择了最简单的方式——当调用方请求句柄时，线程就开始了

use std::thread::{self, JoinHandle};

fn parallelize<B, R>(function: B) -> Box<FnOnce() -> JoinHandle<R>>
where
    B: Send + FnOnce() -> R + 'static,
    R: Send + 'static,
{
    Box::new(|| thread::spawn(function))
}

使用std:：thread:：{self，JoinHandle}；
fn并行化（功能：B）->Box JoinHandle>
哪里
B:Send+FnOnce（）->R+'静态，
R:发送+'静态，
{
框：：新建（| |线程：：生成（函数））
}

我想你也可以马上开始：

use std::thread::{self, JoinHandle};

fn parallelize<B, R>(function: B) -> Box<FnOnce() -> JoinHandle<R>>
where
    B: Send + FnOnce() -> R + 'static,
    R: Send + 'static,
{
    let handle = thread::spawn(function);
    Box::new(|| handle)
}

使用std:：thread:：{self，JoinHandle}；
fn并行化（功能：B）->Box JoinHandle>
哪里
B:Send+FnOnce（）->R+'静态，
R:发送+'静态，
{
让handle=thread:：spawn（函数）；
盒子：新的（| |把手）
}

我不知道你为什么要做第二个；在这种情况下，您最好直接返回句柄。如果您这样做了，那么您最好直接调用

thread:：spawn

哦，我想我不能从你身边溜走，是吗？调用

thread:：spawn

时，必须确保传递给它的任何内容在线程退出（因此

静态

）之前都不会停止有效，并且可以在线程之间安全传输（因此

发送

）

更高级别的目标是在迭代器上实现并行映射函数

它存在并被称为

---

另见：