Does a detached thread keep its captured shared_ptr alive?

Question

If I have a shared_ptr that I copy into a std::thread, detach the thread, and then I destroy all other copies of the shared_ptr, can I expect the detached thread to continue to have a live copy of the shared_ptr? For example if I have:

{
    std::shared_ptr<Foo> my_foo = std::make_shared<Foo>();
    std::thread soon_detached([my_foo = my_foo]() {my_foo->bar()});
    soon_detached.detach();
}

Can I trust that bar() is "safe" to call in that situation (in that it won't try to call bar on a Foo that's being destructed/is destructed even if the initial copy of my_foo is long out of scope?

Since you’ve captured by value, you’ve increased the reference counter, which will be decreased again at the end of the lambda’s scope. — Konrad Rudolph
Why do you think detaching the thread could make a difference here? — davmac
Usual warning about detached threads: Be really, really sure this is the behaviour you want. You've ceded all control of the thread and this often ends poorly. If you've already taken steps to mitigate this, groovy. If not, know there there may be steps that need to be taken. — user4581301
@AryanSefidi in my understanding the lambda object itself is copied (actually, moved) when you create the thread object. It will belong however to the underlying thread, not the thread object itself; so, destroying the thread object won't destroy the lambda object, nor the shared_ptr it contains, and neither will detaching the thread. — davmac
Example program to demonstrate. It's a little complicated, and it might help to remove the shared_ptr altogether, so you can see the lifetime of the foo2 object more clearly: godbolt.org/z/1GrsjnxY4 — davmac

eerorika eerorika · Accepted Answer · 2021-06-10T23:00:55

Does a detached thread keep its captured shared_ptr alive?

Yes. The lambda - and thus also the captures of the lambda - will stay alive as long as the thread is executing. Same would also apply to args passed into std::thread.

we're deleting our own handle to the std::thread at the end of the scope

The std::thread object won't contain the functor. It will need to be stored in dynamic memory. The lifetime of the executing thread is separate from the lifetime of the std::thread wrapper.

Does a detached thread keep its captured shared_ptr alive?

1 Answers