如何为std :: async修改std :: launch策略？

Question

Suppose I want to use std::async for parallelism in my c++ code to run a computationally heavy function func . Now since it is a heavy function, we might at first use std::launch::deferred policy for it as the situation is that we may not need to run after all.

But again if ever we need to execute them suddenly in the future, we desire to run in parallel. Then how can we modify the std::launch policy afterwards.

[Well, one can say that why don't you then suddenly create the std::async s as suddenly you need to execute. But I am assuming here that I cannot do that.]

Or, is there any better and cleaner way to do this other than using std::async ?

Any help is highly appreciated. Thanks in advance.

#include <future>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <iostream>

std::vector<double> func(size_t n) // a computationally heavy function
{
    std::vector<double> vec(n);
    std::generate_n(vec.begin(), n, std::rand);
    return vec;
}

int main()
{
    // create asyncs, now deferred for lazy execution
    auto v1 = std::async(std::launch::deferred, func, 200); // deferred for lazy execution
    auto v2 = std::async(std::launch::deferred, func, 250); // deferred for lazy execution

    // only after sometime we decide to execute both of them
    // but we also now want them to execute in parallel

    // so how can we now change the launch policy?

    // to get the values as quickly as can be
    auto n1 = v1.get().size();
    auto n2 = v2.get().size();

    std::cout<<"Got "<<n1<<" and "<<n2<<" random numbers in parallel!"<<std::endl;
    return 0;
}

UPDATE

Thinking a little bit more leads me with this issue:

After defining the std::async with std::launch::deferred , when one calls the .get() function, will it then be guaranteed to run async (ie in parallel) Surely, not. http://en.cppreference.com/w/cpp/thread/launch says

it is executed on the calling thread.

Then the very notion of async gets spoilt, right?

Answer 1

If the std::async uses std::launch::deferred then it is run when the returned std::future object's get() function is called.

This suggests you could force std::launch::async like this:

int s1 = 0;
int s2 = 0;

auto v1 = std::async(std::launch::deferred, []{ return 1; });
auto v2 = std::async(std::launch::deferred, []{ return 2; });

// some fancy coding ...

if(need_to_upgrade_launch_policy())
{
    auto v1a = std::async(std::launch::async, [&]{ return v1.get(); });
    auto v2a = std::async(std::launch::async, [&]{ return v2.get(); });

    s1 = v1a.get();
    s2 = v2a.get();
}

//  more clever coding ...

if(v1.valid()) // was never upgraded
    s1 = v1.get();

if(v2.valid()) // was never upgraded
    s2 = v2.get();