Come si uccide un thread in c++?

• Un thread potrebbe aver aperto un file per la scrittura e, se viene ucciso, il file non sarebbe chiuso. Questo è un problema.
• Un thread potrebbe aver acquisito un blocco sulle risorse del computer per il suo unico utilizzo. Se il thread viene ucciso, le risorse rimarranno bloccate e altri thread e processi non saranno in grado di utilizzare le risorse.
• La memoria assegnata deve essere rilasciata. Il thread potrebbe aver assegnato un po 'di memoria per qualche scopo. Se il thread viene ucciso, la memoria rimarrà falsamente allocata e non disponibile per altri thread e processi. Questa è una perdita di memoria.

Questi motivi e qualsiasi altro mezzo che, se un thread viene ucciso, le risorse che potrebbe aver acquisito non verrebbero rilasciate per l'uso da altri thread e processi. Quando un thread completa naturalmente, viene rilasciata qualsiasi risorsa acquisita.

Il motivo tipico per uccidere un thread è che l'utente non ha più bisogno del risultato del thread.

Ci sono alcune buone notizie: C ++ 20 è l'ultima versione di C ++ oggi. La classe di thread di C ++ 20 ha componenti per rilasciare le risorse, di un thread, prima della sua estremità naturale e di spostarla prima della sua estremità naturale. In questo modo, C ++ sta fermando il thread e non uccide il thread. Detto in altro modo, C ++ 20 sta uccidendo il thread in modo responsabile. Il rilascio di risorse e l'arresto del thread sono automatici. Nota: non tutti i thread possono essere arrestati in questo modo. Tali thread completerebbero naturalmente, anche se viene fatto un tentativo di fermarli.

La libreria thread ha le seguenti classi per fermarti con il rilascio di risorse: stop_token, stop_source e stop_callback. Ognuna di queste classi può avere oggetti da istanziamento. Tuttavia, in questo tutorial è considerato solo stop_token e stop_source.

Il comando di eseguire un programma di thread, con il compilatore G ++, per C+20, dovrebbe essere simile a:

g ++ -std = c ++ 2a temp.cpp -lpthread -o temp

Questo tutorial spiega come fermare un thread con le risorse rilasciate. L'arresto di un thread con le risorse rilasciate è un modo responsabile di uccidere un thread. Questo tutorial inizia con un riepilogo della codifica di un thread.

Contenuto dell'articolo

• Riepilogo della codifica del thread
• La classe JThread
• Richiesta di fermare un thread
• È possibile fermare?
• È stato effettuato la richiesta di arresto?
• Conclusione

Riepilogo della codifica del thread

Un programma in esecuzione in C ++ è un processo. Un thread è un sotto-processo di un processo. Un semplice programma C ++ ha un solo thread, che è la funzione principale (). La funzione principale () non è un thread formalmente dichiarato. Qualsiasi altro thread per lo stesso programma deve essere formalmente dichiarato. Può esserci più di un thread in un programma.

Un thread è istanziato da una classe thread della libreria thread. Il primo argomento della dichiarazione di un oggetto thread è il nome di una funzione di alto livello. La funzione di alto livello è il filo efficace. Quando l'oggetto viene istanziato, la funzione di livello superiore inizia a eseguire (in esecuzione).

C'è un thread chiamante e un thread chiamato. Sfortunatamente, se il thread chiamato non è unito dal corpo della funzione del thread chiamato, il thread chiamante può completare la sua esecuzione senza che il thread chiamato abbia completato la propria esecuzione. Questo significa guai. Quindi, il corpo funzione del thread chiamante dovrebbe sempre unirsi al thread chiamato dopo l'istanziazione del thread chiamato.

Nel seguente programma, viene istanziato un oggetto thread, utilizzando la funzione di livello superiore, fn ():

#includere
#includere
Utilizzo dello spazio dei nomi std;
void fn ()
cout <<"first code segment of thread" <cout <<"second code segment of thread" <
int main ()

Discussione Thr (fn);
thr.giuntura();
restituzione 0;

L'output è:

Primo segmento di codice del thread
Segmento del secondo codice del thread

Nota l'inclusione della libreria di thread. Nota come sono state codificate le prime e le seconde dichiarazioni della funzione principale. La funzione principale () è il thread principale. fn () è una funzione di alto livello.

La classe JThread

Il jthread è una classe definita nella libreria thread. È come la classe thread ma ha il vantaggio che può essere utilizzato per fermare un thread rilasciando risorse. Ha funzioni membro per restituire un oggetto stop_token e un oggetto stop_source. Le funzioni del membro sono:

stop_source get_stop_source ()
stop_token get_stop_token ()

Ha anche la funzione membro per effettuare una richiesta di arresto, che è:

bool request_stop ()

A partire da ora, nell'ottobre 2021, molti compilatori C ++ stanno ancora implementando la classe JThread. Tuttavia, i campioni di codice indicati di seguito dovrebbero funzionare quando il compilatore ha implementato la classe JThread.

Richiesta di fermare un thread

L'arresto del thread significa fermare la funzione di livello superiore. Una richiesta di fermare significa che il thread dovrebbe fermarsi il prima possibile. Se la richiesta non è concessa, il thread verrà eseguito al completamento e non si fermerà prima della sua fine.

Come indicato sopra, un thread istanziato da JThread ha le funzionalità per uccidere un thread in modo responsabile (impedisce a un thread di rilasciare le sue risorse). La funzione membro per richiedere questo arresto è:

bool request_stop ()

Il valore di ritorno è vero se la richiesta è stata accettata e falsa altrimenti. Accettare la richiesta non garantisce che il thread si fermerà il prima possibile. Potrebbe non essere possibile implementare la richiesta e il thread non si fermerà fino alla sua fine naturale. Cioè, restituire vero non significa che sia possibile fermare. Il seguente programma illustra l'uso di questa funzione membro dell'oggetto JThread:

#includere
#includere
Utilizzo dello spazio dei nomi std;
void fn ()
cout <<"first code segment of thread" <cout <<"second code segment of thread" <
int main ()

JThread Thr (FN);
thr.request_stop ();
thr.giuntura();
restituzione 0;

Questo programma è simile a quanto sopra, ma per due punti:

• Il thread, thr è istanziato dalla classe JThread.
• L'istruzione (richiesta) di arrestare il thread il prima possibile viene rilasciata prima dell'istruzione join (). In questo caso, il thread chiamante è impedire al thread chiamato di continuare a eseguire.

È possibile fermare?

In alcune situazioni, non è possibile fermare un thread. Tuttavia, il programmatore non può sapere se un thread può essere fermato o meno. In questo caso, il programmatore deve chiedere. Lo stop_source ha la funzione membro,

bool stop_possible () const

Se il valore di ritorno è vero, è possibile fermare il thread prima della sua estremità naturale. Se il valore di ritorno è falso, è impossibile fermare il thread prima della sua estremità naturale. JThread ha un metodo che può restituire l'oggetto Stop_Source.

Quindi, potrebbe essere meglio chiedere se un thread può essere fermato prima di fermare il thread. Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
void fn ()
cout <<"first code segment of thread" <cout <<"second code segment of thread" <
int main ()

JThread Thr (FN);
stop_source ss = thr.get_stop_source ();
if (ss.stop_possible ())
thr.request_stop ();
altro
cout <<"Thread could be stopped!" <thr.giuntura();
restituzione 0;

Il segmento del codice di arresto è stato inserito prima dell'istruzione join.

È stato effettuato la richiesta di arresto?

Se è possibile fermare un thread, ciò non garantisce ancora che un'istruzione request_stop () riuscirà a fermare il thread prima della sua estremità naturale. Se il thread non si è fermato prima della sua estremità naturale come sperato, il programmatore potrebbe voler sapere se il thread era stato chiesto di fermarsi con l'istruzione request_stop ().

L'oggetto stop_token ha la funzione membro,

bool stop_request ()

Questa funzione restituisce vera se è stata presentata una richiesta di arresto e falsa altrimenti. L'oggetto JThread può restituire un oggetto stop_token, con la sua funzione membro,

stop_token get_stop_token () const

Il seguente codice funzione principale () illustra come sapere se è stato emesso un request_stop:

int main ()

JThread Thr (FN);
stop_source ss = thr.get_stop_source ();
if (ss.stop_possible ())
thr.request_stop ();
altro
cout <<"Thread could be stopped!" <stop_token st = thr.get_stop_token ();
Se (st.stop_request ())
cout <<"Still waiting for thrread to stop." <altro
thr.request_stop ();
thr.giuntura();
restituzione 0;

Tutto il codice di arresto è prima dell'istruzione join. Non confondere tra le funzioni di richiesta_stop () e stop_request ().

Conclusione

Un thread può essere ucciso in modo responsabile con C ++ 20 e superiore. Ciò significa fermare il thread con le risorse del thread, liberato. La libreria thread ha le classi stop_token, stop_source, stop_callback e jthread per uccidere un thread in modo responsabile. Per utilizzare gli oggetti Stop_Token, Stop_Source e Stop_Callback istanziati, crea il thread con la classe JThread. La classe JThread è nella libreria thread, che deve essere inclusa nel programma C ++.

La classe JThread ha funzioni membro per restituire gli oggetti Stop_Token e Stop_Source. La stessa classe JThread ha la funzione membro, request_stop (), per fermare un thread. È probabile che questa richiesta sia concessa, ma non vi è alcuna garanzia che sarà concessa. Se la richiesta è concessa, il thread si ferma il prima possibile, senza raggiungere la sua fine naturale, tutto è uguale.

L'oggetto stop_source può essere usato per sapere se è possibile arresto un thread. L'oggetto stop_token può essere usato per sapere se è stato emesso un request_stop (). Una volta presentata una richiesta di arresto, non può essere ritirata (una richiesta di arresto successiva non ha alcun effetto).