¿Cuándo debería usar std :: thread :: detach?

En algún momento tengo que usar std::thread para acelerar mi aplicación. También sé que join() espera hasta que se complete un hilo. Esto es fácil de entender, pero ¿cuál es la diferencia entre llamar a detach() y no llamarlo?

Pensé que sin detach() , el método del hilo funcionará usando un hilo de forma independiente.

No separar:

 void Someclass::Somefunction() { //... std::thread t([ ] { printf("thread called without detach"); }); //some code here } 

Llamando con desapego:

 void Someclass::Somefunction() { //... std::thread t([ ] { printf("thread called with detach"); }); t.detach(); //some code here } 

    En el destructor de std::thread , se llama a std::terminate si:

    • el hilo no se unió (con t.join() )
    • y tampoco se separó (con t.detach() )

    Por lo tanto, siempre debe join o detach un hilo antes de que los flujos de ejecución lleguen al destructor.


    Cuando termina un progtwig (es decir, retornos main ), los subprocesos separados que se ejecutan en segundo plano no son atendidos; en su lugar, se suspende su ejecución y se destruyen los objetos locales de subprocesos.

    Fundamentalmente, esto significa que la stack de esos hilos no se desenrolla y, por lo tanto, algunos destructores no se ejecutan. Dependiendo de las acciones que se suponía debían llevar a cabo los destructores, esta podría ser una situación tan mala como si el progtwig se hubiera estrellado o hubiera sido asesinado. Es de esperar que el sistema operativo libere los lockings en los archivos, etc., pero podría haber dañado la memoria compartida, los archivos medio escritos y cosas por el estilo.


    Entonces, ¿deberías usar join o detach ?

    • Use join
    • A menos que necesite tener más flexibilidad Y esté dispuesto a proporcionar un mecanismo de sincronización para esperar a que termine la secuencia por su cuenta , en cuyo caso puede usar detach

    Deberías llamar a detach si no vas a esperar a que el hilo se complete con join pero el hilo en su lugar continuará ejecutándose hasta que finalice y luego terminará sin tener el hilo principal esperándolo específicamente.

    detach básicamente liberará los recursos necesarios para poder implementar join .

    Cuando separa el hilo, significa que no tiene que join() antes de salir de main() .

    La biblioteca de subprocesos realmente esperará cada uno de estos subprocesos a continuación , pero no debería preocuparse por ello.

    detach() es principalmente útil cuando tienes una tarea que tiene que hacerse en segundo plano, pero no te importa su ejecución. Esto suele ser un caso para algunas bibliotecas. Pueden crear silenciosamente un hilo de trabajador de fondo y separarlo para que no lo notes.

    De acuerdo con cppreference.com :

    Separa el hilo de ejecución del objeto de hilo, permitiendo que la ejecución continúe de forma independiente. Cualquier recurso asignado se liberará una vez que el hilo se cierre.

    Después de llamar a detach *this ya no posee ningún hilo.

    Por ejemplo:

      std::thread my_thread([&](){XXXX}); my_thread.detach(); 

    Observe la variable local: my_thread , mientras que la vida útil de my_thread ha terminado, se my_thread al destructor de std::thread y std::terminate() se llamará dentro del destructor.

    Pero si usa detach() , ya no debería usar my_thread , pero si la vida de my_thread ha terminado, no pasará nada al nuevo hilo.