c++ - 在一次调用中启动多个线程 C++ 11

Question

据我所知，在 C++ 11 中创建多线程的典型方法是:

int num_threads = 10;
std::thread threads[num_threads];
for(int i = 0; i < num_threads; ++i)
{
    threads[i] = std::thread(doSomething);
}
// Call join if you need all threads completion
for(int i = 0; i < num_threads; ++i)
{
    threads[i].join();
}

是否可以一次启动线程，而不是使用循环依次启动每个线程。我知道在 CUDA 中，线程是同时启动的，没有必要单独启动每个线程。想知道 C++ 11 中是否可能有类似的东西。

Answer 1

是的，您可以生成一个操作，该操作将在一个语句中启动 n 个线程(嗯，逻辑上)。

template<class F>
std::future<void> launch_tasks( F&& f, size_t n ) {
  if (n==0) { // ready future case, launch 0 threads:
    std::promise<void> p;
    p.set_value();
    return p.get_future();
  }
  std::vector<std::future<void>> results;
  results.reserve(n-1);
  for (size_t i = 0; i < n-1; ++i) {
    results.push_back(
      std::async(
        std::launch::async,
        f, i
      )
    );
  }
  // last thread waits on the previous threads before finishing:
  return std::async(
    std::launch::async,
    [results=std::move(results),f=std::forward<F>(f)]{
      f(results.size());
      for (auto&& others:results)
        others.wait();
    }
  };
}

只需调用 launch_tasks( [](size_t i) {/* code */}, n ) 将启动 n 任务，每个任务都有一个索引。返回的 future 将阻塞所有正在完成的任务，而无需为该任务使用额外的线程。

这是对最后一个 lambda 使用 C++14 特性(通用捕获)。你可以这样写一个函数对象:

template<class F>
struct work_then_wait {
  F f;
  std::vector<std::future<void>> futures;
  void operator()()const{
    f(futures.size());
    for (auto&& f:results)
      f.wait();
  }
};

然后

return work_then_wait<typename std::decay<F>::type>{
  std::forward<F>(f),
  std::move(results)
};

代替 lambda，它是等效的，但用 C++11 编写。

一个更简单的版本在等待所有 future 的任务上使用 std::async( std::launch::deferred ，但这使得 wait_until 和其他定时等待返回的 future 没用。