Jinbom Heo Jinbom Heo - 29 days ago 18
C++ Question

When should I use std::thread::detach?

Sometime I have to use

std::thread
to speed up my application. I also know
join()
waits until a thread completes. This is easy to understand, but what's the difference between calling
detach()
and not calling it?

I thought that without
detach()
, the thread's method will work using a thread independently.

Not detaching:

void Someclass::Somefunction()
{
//...

std::thread t([ ] {

printf(“hello, this is thread calling without detach!”);

});

//some code here
}


Calling with detaching:

void Someclass::Somefunction()
{
//...

std::thread t([ ] {

printf(“hello, this is thread calling with detach!”);

});

t.detach();

//some code here

}

Answer

In the destructor of std::thread, std::terminate is called if:

  • the thread was not joined (with t.join())
  • and was not detached either (with t.detach())

Thus, you should always either join or detach a thread before the flows of execution reaches the destructor.


When a program terminates (ie, main returns) the remaining detached threads executing in the background are not waited upon; instead their execution is suspended and their thread-local objects destructed.

Crucially, this means that the stack of those threads is not unwound and thus some destructors are not executed. Depending on the actions those destructors were supposed to undertake, this might be as bad a situation as if the program had crashed or had been killed. Hopefully the OS will release the locks on files, etc... but you could have corrupted shared memory, half-written files, and the like.


So, should you use join or detach ?

  • Use join
  • Unless you need to have more flexibility AND are willing to provide a synchronization mechanism to wait for the thread completion on your own, in which case you may use detach