Start remaining futures without blocking - c++

Question

I have a loop over a set where I have to perform an expensive calculation. I want to do this in parallel using the future class. As far as I understand this, async either starts the thread or defers it and starts it only when I call get() or wait(). So, when I have threads not started and try to get the result, I block the main thread an get a sequential processing. Is there a way to start the remaining deferred processes, so everything is calculated in parallel and will not block when I call get().
// do the calculations
std::vector<std::future<class>> futureList;
for (auto elem : container)
{
futureList.push_back(std::async(fct, elem));
}
// start remaining processes
// use the results
for (auto elem : futureList)
{
processResult(elem.get())
}
Thanks for your help.

Answer 1

You might use:
std::async(std::launch::async, fct, elem)
Sample:
#include <iostream>
#include <future>
#include <chrono>
#include <vector>
#include <stdexcept>
bool work() {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
if( ! (std::rand() % 2)) throw std::runtime_error("Exception");
return true;
}
int main() {
const unsigned Elements = 10;
typedef std::vector<std::future<bool>> future_container;
future_container futures;
for(unsigned i = 0; i < Elements; ++i)
{
futures.push_back(std::async(std::launch::async, work));
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
while( ! futures.empty()) {
future_container::iterator f = futures.begin();
while(f != futures.end())
{
if(f->wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout) ++f;
else {
// Note:: Exception resulting due to the invokation of
// the thread are thrown here.
// (See 30.6.6 Class template future)
try {
std::cout << f->get() << '\n';
}
catch(const std::exception& e) {
std::cout << e.what() << '\n';
}
f = futures.erase(f);
}
}
}
return 0;
}

Answer 2

You may do something like : (http://coliru.stacked-crooked.com/a/005c7d2345ad791c)
Create this function:
void processResult_async(std::future<myClass>& f) { processResult(f.get()); }
And then
// use the results
std::vector<std::future<void>> results;
for (auto& elem : futureList)
{
results.push_back(std::async(std::launch::async, processResult_async, std::ref(elem)));
}