将节点划分为线程c ++

Question

所以我有一个输出计算程序，给定mxn矩阵中的节点数量（n = 5），生成节点的输出，直到在迭代次数内达到收敛（迭代= 100）。 p>

我想拥有2个线程，因此1个线程将计算3个节点，第二个线程将计算2个节点。 目前我的程序将迭代分为2并在两者中运行我的计算程序而不是在它们之间划分计算，给出两次输出，这比仅运行单个线程需要更长的时间。

void calculations() {
  //do matrix calculations
  double matrix[n][n] = { {1,2,3,4,5}, {...}, {...}, {...}, {...} };
  double results = {1,2,3,4,5};
  ...
  //print calculations here
}

int _tmain(int argc, _TCHAR* argv[]){
  //multi thread calculations
  thread* threads[2];
  for (int proc = 0; proc < 2s; proc++) {
      threads[proc] = new thread(calculations);
  }
  for (thread *t : threads) {
      t->join();
  }

  return 0;
}

我如何写这个来划分线程中的计算，而不是只输出两次程序？我假设我需要sperate线程方法？

Answer 1

这只是一个使用std :: tuple从两个线程返回两个叶子节点的片段（您可以更改为输出2-3个叶子节点）。由于线程无法将值返回给调用程序，因此可以将std :: future与std：promise一起使用（代码是自解释的）。

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

using namespace std;

void node_calc(promise<tuple<double,double>>& p)
{
    tuple<double,double> result; 
    //result = calculate here
    result = std::make_tuple(10,100);
    p.set_value(result);
}

int main()
{    
    thread threads[2];
    vector<future<tuple<double,double>>> future_results;

    for(int i=0;i<2;i++)
    {
        promise<tuple<double,double>> p ;
        future<tuple<double,double>> f = p.get_future();
        threads[i] = thread( [&]() { node_calc(p); } );
        future_results.push_back(std::move(f));
    }

    threads[0].join();
    threads[1].join();

    vector<double> results;
    for(auto& f:future_results)
    {   
        tuple<double,double> t = f.get();
        results.push_back(std::get<0>(t));
        results.push_back(std::get<1>(t));
    }

    for(auto result:results)
    {
        cout << result <<" ";
    }

} 

测试输出