Question

With threads I know that terminate() is called when the thread-variable leaves scope:

size_t fibrec(size_t n) {
  return n<2 ? 1 : fibrec(n-2)+fibrec(n-1);
}

int main() {
    std::thread th{ fibrec, 35 };
    // no join here
} // ~th will call terminate().

ths destructor will call terminate() when it leaves scope.

But what about futures? Where is the thread they run going? Is it detached? How is it ended?

#include <iostream>
#include <future> // async
using namespace std;

size_t fibrec(size_t n) {
    return n<2 ? 1 : fibrec(n-2)+fibrec(n-1);
}

struct Fibrec {
    size_t operator()(size_t n) { return fibrec(n); }
    const size_t name_;
    Fibrec(size_t name) : name_(name) {}
    ~Fibrec() { cerr << "~"<<name_<< endl; }
};

void execit() {
    auto f1 = async( Fibrec{33}, 33 );
    auto f2 = async( Fibrec{34}, 34 );
    // no fx.get() here !!!
}; // ~f1, ~f2, but no terminate()! Where do the threads go?

int main() {
    auto f0 = async( Fibrec{35}, 35 );
    execit();
    cerr << "fib(35)= " << f0.get() << endl;
}

When execit() is left the futures f1 and f2 are destroyed. But their threads should still be running? The destructor of Fibrec is called, of course. But where are the threads going? The program does not crash, so I guess, the become joined? Or maybe detached? Or are they stopped or canceled? I believe that is not trivially done in C++11?

Answer 1

The future is the result of the async operation, it’s is not a thread by itself. The async function spawns a new thread to do the computation, and when that is finished, the result is written to a future object.

Depending on the implemented policy, you will either have to call .get() or .wait() on the future to get the result. Invoking this will do the work on the thread on which it is called

If policy is std::launch::async then runs INVOKE(fff,xyz…) on its
own thread. The returned std::future will become ready when this
thread is complete, and will hold either the return value or exception
thrown by the function invocation. The destructor of the last future
object associated with the asynchronous state of the returned
std::future shall block until the future is ready.

If policy is std::launch::deferred then fff and xyz… are stored
in the returned std::future as a deferred function call. The first
call to the wait() or get() member functions on a future that shares
the same associated state will execute INVOKE(fff,xyz…)
synchronously on the thread that called wait() or get().