产生多个线程，每个线程返回多个值

Question

我正在尝试生成将执行给定任务的多个线程。此任务根据传入的内容而有所不同，并将返回多个值。

我尝试了以下几行但没有运气：

std::vector<std::tuple<std::thread, Task, Result1, Result2>> workers;
for (auto const& task : tasks) {
    Result1 result1;
    Result2 result2;
    std::tuple<std::thread, Task, Result1, Result2> worker = std::make_tuple(std::thread(&Slave::performTask, this, task, std::ref(result1), std::ref(result2)), task, result1, result2);
    workers.emplace_back(worker);
}
for (auto& w : workers) {
    std::get<0>(w).join();
    std::cout << "Task=" << std::get<1>(w) << " Result1=" << std::get<2>(w) << " Result2=" << std::get<3>(w) << std::endl; 
}

我认为问题在于在嵌套容器中引用 std::thread 导致 workers.emplace_back(worker); 无效。我尝试在几个地方使用 std::move 没有成功。

workers.emplace_back(worker); 导致以下错误：

external/libcxx/include/thread:268:5: 错误：'std::__1::thread::thread(const std::__1::thread&)' 是私有的 线程（常量线程&）；

external/libcxx/include/type_traits:887:87: 错误：在此上下文中 sizeof(__is_convertible_imp::__test<_t2>(__is_convertible_imp::__source<_t1>())) == 1

external/libcxx/include/type_traits:851:28: 错误：初始化 'char std::__1::__is_convertible_imp::__test(_Tp) [with _Tp = std::__1::thread]' 的参数 1 模板字符 __test(_Tp);

按照 Daniel 的要求，我整理了一个最小的可编译示例。它在 cpp.sh 上正确编译和执行：

#include <iostream>
#include <thread>
#include <tuple>
#include <vector>

using Task = std::string;
using Result1 = std::string;
using Result2 = std::string;

class Slave {
    private:
    void performTask(Task task, Result1& result1, Result2& result2) {
        if (task == "A") {
            result1 = "A1";
            result2 = "A2";
        } else if (task == "B") {
            result1 = "B1";
            result2 = "B2";
        } else {
            result1 = "C1";
            result2 = "C2";
        }
    }
    public:
    std::vector<Task> tasks;
    std::vector<std::tuple<Task, Result1, Result2>> performParallel() {
        std::vector<std::tuple<Task, Result1, Result2>> results;
        std::vector<std::tuple<std::thread, Task, std::unique_ptr<Result1>, std::unique_ptr<Result2>>> workers;
        for (auto const& task : tasks) {
            std::unique_ptr<Result1> result1(new Result1);
            std::unique_ptr<Result2> result2(new Result2);
            std::tuple<std::thread, Task, std::unique_ptr<Result1>, std::unique_ptr<Result2>> worker = std::make_tuple(std::move(std::thread(&Slave::performTask, this, task, std::ref(*result1), std::ref(*result2))), task, std::move(result1), std::move(result2));
            workers.emplace_back(std::move(worker));
        }
        for (auto& w : workers) {
            std::get<0>(w).join();
            std::tuple<Task, Result1, Result2> result = std::make_tuple(std::get<1>(w), *std::get<2>(w), *std::get<3>(w));
            results.emplace_back(result);
        }
        return results;
    }
};

int main() {
    Slave slave;
    slave.tasks = { "A", "B", "C" };
    std::vector<std::tuple<Task, Result1, Result2>> results = slave.performParallel();
    for (auto const& r : results) {
        std::cout << "Task=" << std::get<0>(r) << " Result1=" << std::get<1>(r) << " Result2=" << std::get<2>(r) << std::endl; 
    }
}

执行输出：

任务=A 结果1=A1 结果2=A2

任务=B 结果1=B1 结果2=B2

任务=C 结果1=C1 结果2=C2

Answer 1

线程不是可复制构造的，因此出现错误'thread(const thread&)' is private

线程是 可移动构造，所以你可以使用std::move emplace_back 一个右值引用：

workers.emplace_back(std::move(worker));

虽然这将解决眼前的问题，但请注意您还有一个更大、更险恶的问题 - 即悬空引用

您正在将对临时对象的引用传递给您的线程函数，（然后使用Result1 和Result2 的副本创建一个元组）

Result1 result1;
Result2 result2;

std::tuple<std::thread, Task, Result1, Result2> worker = 
    std::make_tuple(
        std::thread(
            &Slave::performTask, 
            this, 
            task, 
            std::ref(result1),  <-- here you pass a reference to a local variable
            std::ref(result2)), <-- 
        task, 
        result1,   <-- here you copy construct the tuple member from a local var
        result2);  <--

您的线程将引用对result1 和result2 的悬空引用，并且可能会出现段错误。

您可以先使用空线程对象创建元组，然后创建传递对元组成员的引用的线程，但我不建议这样做。

更好的设计是使用一些封装，将你的线程和结果变量打包到自己的类中

struct Worker
{
    Worker(Task& task)
        : task(task)
        , _thread(&Worker::performTask, this)
    {
    }

    void performTask()
    {
        result1 = task.foo();
        result2 = task.bar();
    }

    void join()
    {
        _thread.join();
    }

    Task    task;
    Result1 result1;
    Result2 result2;

private:
    std::thread _thread;
};

现在您不必尝试使用Result 变量创建元组和将引用传递给线程元组成员。