多次并行调用函数

Question

我想多次调用具有不同arg值的函数。为了更快地执行，我想调用函数而不考虑它的实现。

在一个循环中，我将arg传递给函数并调用它，现在我的程序不应该等待函数执行并再次循环，而应该不考虑该函数未完成第一个循环向前并一次又一次地调用该函数直到循环结束。

如何使用fork和线程来做到这一点，哪一个会更快，代码的骨架会有所帮助？ 假设我的函数是void foo（arg1，arg2）

Answer 1

如果它是一种计算密集型方法，那么为每个调用产生一个线程/进程并不是一个好主意（事实上，它从来不是一个好主意！）。

可以有效地并行for循环使用OpenMP：

#pragma omp parallel for 
for(int i = 0; i < N; i++) 
{ 
    int arg1 = ... 
    int arg2 = ... 
    foo(arg1, arg2); 
} 

这将创建一个线程数根据可用的CPU核心数量，然后它们之间拆分迭代。您可以使用schedule子句进一步调整计划。

Answer 2

你想异步执行的proactor pattern.

下面是一个例子，使用boost::asio和boost::thread：

#include <iostream> 
using namespace std; 

#include <boost/asio.hpp> 
#include <boost/thread.hpp> 

// your function, with its arguments 
void foo(int x, int y) 
{ 
    cout << x << " * " << y << " = " << x * y << "\n"; 
} 

int main() 
{ 
    boost::asio::io_service svc; 
    boost::asio::io_service::work w(svc); 

    // create a thread to run the io_service proactor 
    boost::thread thread(boost::bind(&boost::asio::io_service::run, &svc)); 

    for(int z = 0; z < 32; ++z) 
    { 
     // bind the function to its arguments to 
     // be called in the context of the running 
     // thread 
     svc.post(boost::bind(&f, 2, z)); 
    } 

    boost::this_thread::sleep(boost::posix_time::milliseconds(1000)); 

    svc.stop(); 
    thread.join(); 
} 

这样做的好处，是可以通过，如果线程池调用boost::asio::io_service::run轻松扩展必要。

Answer 3

就像都铎王朝推荐的那样，我也会使用Intel TBB或Microsoft PPL的parallel_for模式算法。

如果你真的想产生一个线程需要为每一个功能，你可以做这样的：

#include <thread> 
#include <vector> 

void foo(arg1, arg2) { 
    //do stuff 
} 

int main() { 

    std::vector<std::thread> threads; 

    for(auto i = x; i != y; ++i) 
    threads.emplace_back(foo, arg1, arg2); 

    for(auto& i: threads) 
    i.join(); 

}