Cosa c'è di diverso tra join() e detach() per il multi-threading in C++?

Question

Cosa c'è di diverso tra join() e detach() in multi threading in C++? join() uccide il thread?

Answer 1

A C++ thread oggetto generalmente (ma non sempre) rappresenta un thread di esecuzione, che è un concetto operativo o piattaforma.

Quando viene chiamato il numero thread::join(), il thread chiamante bloccherà fino al completamento del thread di esecuzione. Fondamentalmente, questo è un meccanismo che può essere usato per sapere quando un thread ha finito. Al ripristino di thread::join(), il thread di esecuzione del sistema operativo è stato completato e l'oggetto C++ thread può essere distrutto.

Viene chiamato il thread::detach(), il thread di esecuzione è "scollegato" dall'oggetto thread e non è più rappresentato da un oggetto thread - sono due cose indipendenti. L'oggetto C++ thread può essere distrutto e il thread di esecuzione del sistema operativo può continuare. Se il programma deve sapere quando il thread di esecuzione è stato completato, è necessario utilizzare altri meccanismi. join() non può più essere chiamato su quell'oggetto thread, poiché non è più associato a un thread di esecuzione.

È considerato un errore distruggere un oggetto C++ thread mentre è ancora "unificabile". Cioè, al fine di distruggere un oggetto C++ thread o join() deve essere chiamato (e completato) o detach() deve essere chiamato. Se un oggetto C++ thread è ancora unificabile quando viene distrutto, verrà generata un'eccezione.

Alcuni altri modi in cui un oggetto C++ thread non rappresentare un thread di esecuzione (ad esempio, può essere unjoinable.):

• Un default costruito thread oggetto non rappresenta un thread di esecuzione, così non è accostabile.
• Un thread che è stato spostato da non rappresenterà più un thread di esecuzione, quindi non è univoco.

Answer 2

join() non uccide il thread. In realtà attende che ritorni la funzione principale del thread. Quindi, se la vostra funzione principale filo appare così:

while (true) { 
} 

join() sta per aspettare per sempre.

detatch() non elimina il thread. In realtà dice a std::thread che questo thread dovrebbe continuare a funzionare anche quando l'oggetto std::thread viene distrutto. C++ controlla in std :: thread destructor che il thread è unito o disconnesso e termina il programma se questo controllo fallisce.

Quindi se si decommenta la prima riga nella funzione main del seguente codice, si bloccherà. Se disattivi la seconda o la terza riga, funzionerà bene.

#include <thread> 

void func() { 
} 

void fail1() { 
    std::thread t(func); 
    // will fail when we try to destroy t since it is not joined or detached 
} 

void works1() { 
    std::thread t(func); 
    t.join(); 
} 

void works2() { 
    std::thread t(func); 
    t.detach(); 
} 

int main() { 
    // fail1(); 
    // works1(); 
    // works2(); 
}