Wie tötest du einen Thread in C++?

• Ein Thread hat möglicherweise eine Datei zum Schreiben geöffnet, und wenn er getötet wird, wäre die Datei nicht geschlossen. Das ist Ärger.
• Ein Thread hat möglicherweise eine Sperre für Computerressourcen für seinen alleinigen Gebrauch erhalten. Wenn der Thread getötet wird, bleiben die Ressourcen gesperrt und andere Fäden und Prozesse können die Ressourcen nicht nutzen.
• Zugewiesener Speicher muss veröffentlicht werden. Der Thread hat möglicherweise einen Gedächtnis für einen Zweck zugewiesen. Wenn der Thread getötet wird, bleibt das Gedächtnis fälschlicherweise zugeteilt und für andere Themen und Prozesse nicht verfügbar. Das ist ein Speicherleck.

Diese und alle anderen Gründe bedeutet, dass, wenn ein Thread getötet wird, Ressourcen, die er erworben hat. Wenn ein Thread natürlich abgeschlossen ist, wird jede erworbene Ressource veröffentlicht.

Das typische Motiv für das Töten eines Threads besteht darin, dass der Benutzer das Ergebnis des Threads nicht mehr benötigt.

Es gibt einige gute Nachrichten: C ++ 20 ist die neueste Version von C ++ heute. Die Thread -Klasse von C ++ 20 verfügt. Auf diese Weise stoppt C ++ den Faden und tötet den Thread nicht ab. Anders ausgedrückt, C ++ 20 tötet den Thread verantwortungsbewusst ab. Die Freisetzung von Ressourcen und das Stoppen des Threads sind automatisch. Hinweis: Nicht alle Threads können auf diese Weise gestoppt werden. Solche Themen würden natürlich abgeschlossen, auch wenn ein Versuch unternommen würde, sie zu stoppen.

Die Thread -Bibliothek verfügt über die folgenden Klassen, um mit der Veröffentlichung von Ressourcen zu stoppen: STOP_TOOKE, STOP_SOURCE und STOP_CALLBACK. Jedes dieser Klassen kann Objekte von instanziiert haben. In diesem Tutorial werden jedoch nur Stop_Token und Stop_Source berücksichtigt.

Der Befehl zum Ausführen eines Thread -Programms mit dem G ++ - Compiler für C+20 sollte ähnlich sein wie:

g ++ -std = c ++ 2a tempe.CPP -LPThread -o -Temp

In diesem Tutorial wird erläutert, wie man einen Thread mit veröffentlichten Ressourcen stoppt. Das Stoppen eines Threads mit veröffentlichten Ressourcen ist eine verantwortungsbewusste Methode, um einen Thread zu töten. Dieses Tutorial beginnt mit einer Zusammenfassung des Codierens eines Threads.

Artikelinhalt

• Zusammenfassung der Thread -Codierung
• Die JThread -Klasse
• Anfrage, einen Thread zu stoppen
• Ist Stopp möglich?
• Wurde eine Stoppanfrage gestellt?
• Abschluss

Zusammenfassung der Thread -Codierung

Ein laufendes Programm in C ++ ist ein Prozess. Ein Thread ist ein Unterprozess eines Prozesses. Ein einfaches C ++ - Programm hat nur einen Thread, der die main () -Funktion ist. Die main () -Funktion ist kein formell deklarierter Thread. Jeder andere Thread für dasselbe Programm muss offiziell deklariert werden. Es kann mehr als einen Thread in einem Programm geben.

Ein Thread wird aus einer Thread -Klasse der Threadbibliothek instanziiert. Das erste Argument der Erklärung eines Thread-Objekts ist der Name einer Funktion auf der obersten Ebene. Die obere Funktion ist der effektive Faden. Wenn das Objekt instanziiert ist, beginnt die Funktion der obersten Ebene auszuführen (ausführen).

Es gibt einen Ruffaden und einen genannten Thread. Wenn der aufgerufene Thread nicht aus dem Funktionsbestand des aufgerufenen Threads verbunden ist, kann der aufrufende Thread seine Ausführung ohne den angerufenen Thread abschließen. Das bedeutet Ärger. Der Funktionskörper des aufrufenden Threads sollte also nach der Instanziierung des genannten Thread.

Im folgenden Programm wird ein Thread-Objekt unter Verwendung der obersten Funktion fn () instanziiert:

#enthalten
#enthalten
Verwenden von Namespace STD;
void fn ()
Cout <<"first code segment of thread" <Cout <<"second code segment of thread" <
int main ()

thread thr (fn);
TH.verbinden();
Rückkehr 0;

Die Ausgabe ist:

Erster Codesegment des Threads
zweiter Codesegment des Threads

Beachten Sie die Aufnahme der Threadbibliothek. Beachten Sie, wie die erste und zweite Aussagen der Hauptfunktion codiert wurden. Die main () -Funktion ist der Hauptfaden. FN () ist eine Funktion auf der obersten Ebene.

Die JThread -Klasse

Das JThread ist eine Klasse, die in der Thread -Bibliothek definiert ist. Es ist wie in der Thread -Klasse, hat aber den Vorteil, dass es verwendet werden kann, um einen Thread durch Freisetzung von Ressourcen zu stoppen. Es verfügt über Mitgliedsfunktionen, um ein Stop_Token -Objekt und ein Stop_Source -Objekt zurückzugeben. Die Mitgliedsfunktionen sind:

STOP_SOURCE get_stop_source ()
stop_token get_stop_token ()

Es hat auch die Mitgliederfunktion, um eine Stoppanfrage zu stellen, dh:

bool request_stop ()

Ab sofort im Oktober 2021 implementieren viele C ++ - Compiler die JThread -Klasse. Die unten angegebenen Codeproben sollten jedoch funktionieren, wenn Ihr Compiler die JThread -Klasse implementiert hat.

Anfrage, einen Thread zu stoppen

Das Stoppen des Faden. Eine Anfrage zum Anhalten bedeutet, dass der Thread so schnell wie möglich anhalten sollte. Wenn die Anfrage nicht erteilt wird, wird der Thread bis zum Abschluss ausgeführt und nicht vor seinem Ende anhalten.

Wie oben angegeben, verfügt ein aus dem JThread instanziierter Thread über die Funktionen, um einen Thread verantwortungsbewusst zu töten (verhindern Sie, dass ein Thread seine Ressourcen freigibt). Die Mitgliedsfunktion, um diesen Stopp anzufordern, lautet:

bool request_stop ()

Der Rückgabewert ist wahr, wenn die Anfrage angenommen wurde und ansonsten falsch ist. Die Annahme der Anfrage garantiert nicht, dass der Thread so schnell wie möglich aufhört. Möglicherweise ist es nicht möglich, die Anfrage zu implementieren, und der Thread hört erst nach seinem natürlichen Ende auf. Das heißt, die Rückkehr von True bedeutet nicht, dass das Stoppen möglich ist. Das folgende Programm zeigt die Verwendung dieser Mitgliedsfunktion des JThread -Objekts:

#enthalten
#enthalten
Verwenden von Namespace STD;
void fn ()
Cout <<"first code segment of thread" <Cout <<"second code segment of thread" <
int main ()

JThread Thr (fn);
TH.Request_Stop ();
TH.verbinden();
Rückkehr 0;

Dieses Programm ähnelt dem oben, aber für zwei Punkte:

• Der Thread, Thr wird aus der JThread -Klasse instanziiert.
• Die Erklärung (Anfrage), den Thread so schnell wie möglich zu stoppen, wird vor der Anweisung join () platziert. In diesem Fall soll der aufrufende Thread verhindern, dass der aufgerufene Thread weiter ausführt.

Ist Stopp möglich?

In einigen Situationen ist es nicht möglich, einen Faden zu stoppen. Der Programmierer kann jedoch nicht wissen, ob ein Thread gestoppt werden kann oder nicht. In diesem Fall muss der Programmierer nachfragen. Die Stop_Source hat die Mitgliedsfunktion,

bool stop_possible () const

Wenn der Rückgabewert wahr ist, ist es möglich, den Faden vor seinem natürlichen Ende zu stoppen. Wenn der Rückgabewert falsch ist, ist es unmöglich, den Faden vor seinem natürlichen Ende zu stoppen. JThread hat eine Methode, die das Stop_Source -Objekt zurückgeben kann.

Es ist also besser zu fragen, ob ein Thread gestoppt werden kann, bevor Sie den Faden anhalten. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace 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 ())
TH.Request_Stop ();
anders
Cout <<"Thread could be stopped!" <TH.verbinden();
Rückkehr 0;

Das Segment für den Stoppcode wurde vor der Join -Anweisung platziert.

Wurde eine Stoppanfrage gestellt?

Wenn es möglich ist, einen Thread zu stoppen, kann dies immer noch nicht garantieren, dass es einer Anweisung Request_Stop () gelingt, den Faden vor seinem natürlichen Ende zu stoppen. Wenn der Faden nicht vor seinem erhofften natürlichen Ende gestoppt ist, möchte der Programmierer möglicherweise wissen, ob der Thread gebeten wurde, mit der Anweisung Request_Stop () anzuhalten.

Das Stop_Token -Objekt hat die Mitgliedsfunktion,

bool stopp_requested ()

Diese Funktion gibt true zurück, wenn eine Stoppanforderung gestellt und ansonsten falsch falsch ist. Das JThread -Objekt kann ein Stop_Token -Objekt mit seiner Mitgliedsfunktion zurückgeben,

stop_token get_stop_token () const

Der folgende Funktionscode von Main () zeigt, wie Sie wissen, ob ein Request_Stop ausgestellt wurde:

int main ()

JThread Thr (fn);
STOP_SOURCE SS = THR.get_stop_source ();
if (ss.stop_possible ())
TH.Request_Stop ();
anders
Cout <<"Thread could be stopped!" <stop_token st = thr.get_stop_token ();
if (st.STOP_REQUEST ())
Cout <<"Still waiting for thrread to stop." <anders
TH.Request_Stop ();
TH.verbinden();
Rückkehr 0;

Der gesamte Stoppcode ist vor der Join -Anweisung vorhanden. Verwechseln Sie nicht zwischen Request_Stop () und Stop_requested () Funktionen.

Abschluss

Ein Faden kann verantwortungsbewusst mit C ++ 20 und höher getötet werden. Dies bedeutet, den Thread mit den Ressourcen des Threads zu stoppen, befreit. Die Thread -Bibliothek hat die Klassen Stop_Token, Stop_Source, Stop_callback und JThread, um einen Thread verantwortungsbewusst zu töten. So erstellen. Die JThread -Klasse befindet sich in der Thread -Bibliothek, die im C ++ - Programm enthalten sein muss.

Die JThread -Klasse verfügt über Mitgliedsfunktionen, um die Objekte stop_token und stop_source zurückzugeben. Die JThread -Klasse selbst hat die Mitgliedsfunktion, Request_Stop (), um einen Thread zu stoppen. Dieser Antrag wird wahrscheinlich erteilt, aber es gibt keine Garantie dafür, dass sie gewährt wird. Wenn die Anfrage erteilt wird, stoppt der Faden so schnell wie möglich, ohne sein natürliches Ende zu erreichen. Alles ist gleich.

Das Stop_Source -Objekt kann verwendet werden, um zu wissen, ob das Stoppen eines Threads möglich ist. Das Stop_Token -Objekt kann verwendet werden, um zu wissen, ob ein Request_Stop () ausgestellt wurde. Sobald ein Stop -Antrag gestellt wurde, kann sie nicht zurückgezogen werden (eine nachfolgende Stoppanfrage hat keine Auswirkungen).