Question

假设我们有一个odd函数bool(int)。我想并行执行此功能，但使用不同的参数（不同的数字）。

bool odd(int i) { return (((i&1)==1)?true:false); }

这是我正在尝试使用的代码（有效但有疣）。

std::size_t num = 256;
std::vector<bool> results(num);
std::vector<std::function<bool(int)>> funcs(num);
std::vector<std::packaged_task<bool(int)>> tasks(num);
std::vector<std::future<bool>> futures(num);
std::vector<std::thread> threads(num);
for (std::size_t i = 0; i < num; i++) {
    results[i] = false;
    funcs[i] = std::bind(odd, static_cast<int>(i));
    tasks[i] = std::packaged_task<bool(int)>(funcs[i]);
    futures[i] = tasks[i].get_future();
    threads[i] = std::thread(std::move(tasks[i]),0); // args ignored
}
for (std::size_t i = 0; i < num; i++) {
    results[i] = futures[i].get();
    threads[i].join();
}
for (std::size_t i = 0; i < num; i++) {
    printf("odd(%d)=%s\n", i, (results[i]?"true":"false"));
}

我想摆脱线程创建的参数，因为它们依赖于函数bool(int)的参数类型。我想制作一个这个代码的函数模板，并能够创建一个大规模的并行函数执行器。

template <typename _returnType, typename ..._argTypes>
void exec_and_collect(std::vector<_returnType>& results,
                      std::vector<std::function<_returnType(_argTypes...)>> funcs) {
    std::size_t numTasks = (funcs.size() > results.size() ? results.size() : funcs.size());
    std::vector<std::packaged_task<_returnType(_argTypes...)>> tasks(numTasks);
    std::vector<std::future<_returnType>> futures(numTasks);
    std::vector<std::thread> threads(numTasks);
    for (std::size_t h = 0; h < numTasks; h++) {
        tasks[h] = std::packaged_task<_returnType(_argTypes...)>(funcs[h]);
        futures[h] = tasks[h].get_future();
        threads[h] = std::thread(std::move(tasks[h]), 0); // zero is a wart
    }
    // threads are now running, collect results
    for (std::size_t h = 0; h < numTasks; h++) {
        results[h] = futures[h].get();
        threads[h].join();
    }
}

然后这样叫：

std::size_t num = 8;
std::vector<bool> results(num);
std::vector<std::function<bool(int)>> funcs(num);
for (std::size_t i = 0; i < num; i++) {
    funcs[i] = std::bind(odd, static_cast<int>(i));
}
exec_and_collect<bool,int>(results, funcs);

我要删除std::thread(std::move(task), 0);行中的零，因为线程完全忽略了它。如果我完全删除它，编译器找不到传递给线程创建的参数，它就会失败。

Answer 1

你可能不会在通用代码中进行微观管理/控制狂。只需执行任何任务returntype()并让调用者处理参数的绑定：

<强> Live On Coliru

#include <thread>
#include <future>
#include <iostream>
#include <vector>
#include <functional>

bool odd(int i) { return (((i&1)==1)?true:false); }

template <typename _returnType>
void exec_and_collect(std::vector<_returnType>& results,
                      std::vector<std::function<_returnType()>> funcs
                    ) {
    std::size_t numTasks = std::min(funcs.size(), results.size());

    std::vector<std::packaged_task<_returnType()>> tasks(numTasks);
    std::vector<std::future<_returnType>> futures(numTasks);

    std::vector<std::thread> threads(numTasks);

    for (std::size_t h = 0; h < numTasks; h++) {
        tasks[h] = std::packaged_task<_returnType()>(funcs[h]);
        futures[h] = tasks[h].get_future();
        threads[h] = std::thread(std::move(tasks[h]));
    }

    // threads are now running, collect results
    for (std::size_t h = 0; h < numTasks; h++) {
        results[h] = futures[h].get();
        threads[h].join();
    }
}

int main() {
    std::size_t num = 8;
    std::vector<bool> results(num);
    std::vector<std::function<bool()>> funcs(num);

    for (std::size_t i = 0; i < num; i++) {
        funcs[i] = std::bind(odd, static_cast<int>(i));
    }
    exec_and_collect<bool>(results, funcs);
}

请注意，这是一个快速的工作，我已经看到了很多过于具体的事情。

特别是所有临时集合都只是纸张重量（甚至在移动到下一个任务之前，你甚至会将每个tasks[h]移出矢量，那么为什么要保留一个死位向量？）
根本没有时间安排;你只是不耐烦地创建新的主题。这不会扩展（同样，你想要可插拔的池模型;请参阅Executor规范和Boost Async＆＃39;这些实现）

更新

一个稍微清理过的版本，演示了不需要的依赖项可以解决的问题：

没有打包任务/线程的临时载体
没有假设/要求拥有std::function<>个包装任务（这会在实施中内部删除动态分配和虚拟调度）
不要求结果必须在向量中（实际上，您可以使用自定义输出迭代器在任何地方收集它们）
移动意识（这可以说是一个复杂的＆＃34;代码的一部分，看到没有std::move_transform，所以使用std::make_move_iterator

<强> Live On Coliru

#include <thread>
#include <future>
#include <iostream>
#include <vector>
#include <algorithm>

#include <boost/range.hpp>

bool odd(int i) { return (((i&1)==1)?true:false); }

template <typename Range, typename OutIt>
void exec_and_collect(OutIt results, Range&& tasks) {
    using namespace std;
    using T = typename boost::range_value<Range>::type;
    using R = decltype(declval<T>()());

    auto tb = std::make_move_iterator(boost::begin(tasks)),
         te = std::make_move_iterator(boost::end(tasks));

    vector<future<R>> futures;

    transform(
            tb, te,
            back_inserter(futures), [](auto&& t) {
                std::packaged_task<R()> task(std::forward<decltype(t)>(t));
                auto future = task.get_future();
                thread(std::move(task)).detach();
                return future;
            });

    // threads are now running, collect results
    transform(begin(futures), end(futures), results, [](auto& fut) { return fut.get(); });
}

#include <boost/range/irange.hpp>
#include <boost/range/adaptors.hpp>

using namespace boost::adaptors;

int main() {
    std::vector<bool> results;
    exec_and_collect(
            std::back_inserter(results), 
            boost::irange(0, 8) | transformed([](int i) { return [i] { return odd(i); }; })
        );

    std::copy(results.begin(), results.end(), std::ostream_iterator<bool>(std::cout << std::boolalpha, "; "));
}

输出

false; false; false; false; false; false; false; false;

请注意，您确实可以写

    exec_and_collect(
            std::ostream_iterator<bool>(std::cout << std::boolalpha, "; "), 
            boost::irange(0, 8) | transformed([](int i) { return [i] { return odd(i); }; })
        );

并且没有任何results容器：）

使用带有参数和非void返回函数的std :: bind中的std :: thread和std :: function

1 个答案:

更新