È sicuro creare un nuovo thread in un loop?

Question

È sicuro creare un nuovo thread all'interno di while loop? Ho provato in questo modo:

std::thread thread(ClientLoop,clientSocket) 

Ma non appena la funzione restituisce genera l'errore.

while (true){ 
    cout << "Waiting for new connections" << endl; 
    clientSocket = accept(listenSocket, nullptr, nullptr); 
    cout << "Client connected" << endl; 
    new thread(ClientLoop,clientSocket);     
} 

In questo modo funziona, ma mi chiedo se non ci siano perdite di memoria. Grazie.

Answer 1

non appena tornare la funzione che genera l'errore

In effetti, non si deve distruggere un oggetto thread accostabile. Se avete bisogno di attendere il completamento del thread più tardi, poi staccarlo:

std::thread thread(ClientLoop,clientSocket); 
thread.detach(); 
// OK to destroy now 

Se hai bisogno di unirsi in un secondo momento, quindi si dovrà archiviare da qualche parte che persiste al di là del ciclo, ad esempio

std::vector<std::thread> threads; 
while (whatever){ 
    clientSocket = accept(listenSocket, nullptr, nullptr); 
    threads.emplace_back(ClientLoop,clientSocket); 
} 

// later 
for (std::thread & t : threads) { 
    t.join(); 
} 

// OK to destroy now 
threads.clear(); 

In questo modo funziona, ma mi chiedo se non ci sono perdite di memoria.

Sì, questo perde. Ogni new crea un oggetto thread e si elimina il puntatore senza eliminarlo o assegnarlo a un puntatore intelligente di cui occuparsi. Come menzionato nei commenti, non solo perde memoria, ma anche handle di thread, che su alcuni sistemi sono una risorsa più scarsa; quindi dopo un po 'potresti scoprire che non puoi lanciare altri thread.

Scollegare una filettatura è il modo di lasciarlo in esecuzione in background senza perdite. Questo fa sì che il thread rilasci le sue risorse quando finisce.

Answer 2

Non c'è alcun problema nel creare il thread in un ciclo, ma potrebbe esserci un problema nel risolvere alla fine del ciclo se è una variabile locale. Per essere legalmente destrutturato, un oggetto thread deve essere detach ed, join o spostato. Se le tue discussioni sono semplicemente “ attiva e dimentica ” e non devi mai sincronizzarle con in seguito (anche per un arresto pulito), quindi chiama semplicemente std::thread::detach sul thread dopo averlo creato. Altrimenti, puoi inserirlo in un std::vector<std::thread>, quindi che puoi trovarlo e unirlo a volte più tardi.

Answer 3

sembra che non si voglia gestire la durata del thread (questo è quasi sempre un errore).

Se si vuole veramente fare questo, è fatto in questo modo:

while (true){ 
    cout << "Waiting for new connections" << endl; 
    clientSocket = accept(listenSocket, nullptr, nullptr); 
    cout << "Client connected" << endl; 
    thread t(ClientLoop,clientSocket); 
    t.detach(); // detach the actual thread from its std::thread handle 
}