main thread waits for std::async to complete [duplicate]

Answer 1

std::async(std::launch::async, fun, nullptr);

Doesn't do anything with the returned std::future, leaving it to be destroyed. That's a problem because std::future's destructor may block and wait for the thread to finish.

The solution is to hold on to the std::future for a while and let it be destroyed after you're done with everything else.

auto locallyScopedVariable = std::async(std::launch::async, fun, nullptr);

locallyScopedVariable will go out of scope at the end of main and then block until it completes.

Note that this still might not do quite what you want. The main thread could immediately yield the processor to the new thread and allow the new thread to run to completion before control is returned. The code can be corrected and still result in the output of the incorrect version.

Answer 2

A std::future object returned by std::async and launched with std::launch::async policy, blocks on destruction until the task that was launched has completed.

Since you do not store the returned std::future in a variable, it is destroyed at the end of the statement with std::async and as such, main cannot continue until the task is done.

If you store the std::future object, its lifetime will be extended to the end of main and you get the behavior you want.

int main()
{
    ...
    auto fut = std::async(std::launch::async, fun, nullptr);
    ...
}

Answer 3

(1) In multi-threading program testing, protect shared resource (cout in this case) from being invoked from different threads at same time using a mutex. (2) Check if future is ready in the main, you can do a timeout also.

void print_id() 
{
    lock_guard<mutex> locker(mutex_);
    cout << "Thread id is:" << this_thread::get_id() << endl;
}

void print( string str) 
{
    lock_guard<mutex> locker(mutex_);
    cout << str << '\n';
}   

bool fun(void *obj)
{
   print("Entry");
   printid();
   Sleep(10000);
   print("Exit");
   return true;
}


int main()
{
    print("Hello");
    printid();
    std::future<bool> fut = std::async(std::launch::async, fun,nullptr);
    while(!fut->_Is_ready() )
    {
     }
    cout << "After call" << endl;
}