Multiple Async Calls in C++

Question

I want to call a method with async multiple times. A simplified example is shown below:

size_t counter(std::string &s)
{
    return s.size();
}

void stringCountAccumulator()
{
    std::vector<std::string> foos = {"this", "is", "spartaa"};
    size_t total = 0;
    for (std::string &s : foos)
    {
        std::future<size_t> fut = std::async(
            std::launch::async,
            counter, s);

        total += fut.get();
    }
    std::cout << "Total: " << total;
}

It seems that, fut.get() blocks other future calls. How can I implement this problem in C++? I need to call a function in a separate thread. This function "returns" a value.

Answer 1

void stringCountAccumulator()
{
  std::vector<std::string> foos = {"this", "is", "spartaa"};
  std::vector<std::future<size_t>> calcs;
  for (auto&& s : foos) {
    calcs.push_back( std::async(
      std::launch::async,
      counter, s)
    );
  }
  std::size_t total = 0;
  for (auto&& fut:calcs)
    total += fut.get();
  std::cout << "Total: " << total << "\n";
}

.get() is blocking. So don't block until you have queue'd up all tasks.

An alternative plan is to write/find a thread pool, and have each task update a possibly atomic (or mutex guarded) counter.

Have a finished-task counter guarded (again, possibly atomic).

Have a promise (of the total) which you fulfill when the last task is finished (fulfilled by the last task).

Return the future from that promise. Now you have a future representing the entire pool of threads calculating their value and adding it up, with lots of concurrency.

Some frameworks, like microsoft's ppl, have a system where it does something like this for you; you have tasks that return values, and a function object that combines the values, and get the result of the combination out of it.