Wie löst man einen Thread in C ab++?

Ein Faden löst sich von was löst sich von was? - Ein Faden löst sich von einem Join ab. Die nächste Frage ist: „Was ist ein Join?” - Anstatt ein Programm von Aussagen zu haben, das von Anfang bis Ende ausgeführt wird, kann das Programm nacheinander in spezielle Abschnitte von Aussagen zusammengefasst werden. Die speziellen Abschnitte werden als Themen bezeichnet, die dann parallel oder gleichzeitig ausgeführt werden können. Um eine Reihe von Anweisungen in einen Thread umzuwandeln, ist eine spezielle Codierung erforderlich. Leider würden Threads in C ++ unabhängig laufen, wenn sie nicht verbunden würden. In einer solchen Situation kann ein zweiter Thread enden, nachdem der Hauptfaden beendet ist. Dies ist normalerweise nicht wünschenswert.

Damit es jegliche Verbindung gibt, werden zwei Threads benötigt. Ein Thread ruft den anderen Thread auf. Wenn der Thread zusammengefügt wird, kann er an einer Position stehen und darauf warten, dass der angerufene Thread seine Ausführung (bis zu seinem Ende) abschließt, bevor er seine eigene Ausführung fortsetzt. An der Position, an der der Faden anhielt. Ein solches Stalten heißt Blocking.

Wenn der angerufene Thread zu lange dauert, um zu vervollständigen, und wahrscheinlich das getan hat, was der aufrufende Thread erwartet hat, kann der aufrufende Thread ihn lösen. Wenn nach dem Abnehmen der angerufene Thread nach dem Anruf von Thread abgeschlossen ist, sollte es kein Problem geben. Abstand bedeutet, den Join (Link) zu brechen.

Abrufen

Ein Thread ist eine Funktion oberster Ebene, die in ein Thread-Objekt eingeschlossen wurde, das aus der Thread-Klasse instanziiert wurde. Wenn Sie den Thread mit der Funktion über die obere Ebene instanziieren, müssen Sie die Funktion aufrufen. Hier ist ein einfaches Thread -Programm mit der Join -Anweisung:

#enthalten
#enthalten
Verwenden von Namespace STD;
void func ()
Cout <<"… from thread!" <<'\n';

int main ()

Thread thd (func);
thd.verbinden();
/ * Aussagen */
Rückkehr 0;

Hier gibt es zwei Threads: das Objekt, das THD und die main () -Funktion. Die Hauptfunktion ist wie der Hauptfaden. Beachten Sie die Aufnahme der Threadbibliothek. Die Ausgabe ist:

… Vom Thread!

Bei der Eingabeaufforderung sollte ein C ++ 20 -Programm mit Threads für den G ++ - Compiler wie folgt befohlen werden:

g ++ -std = c ++ 2a Probe.cc -lpThread -o -Probe.exe

Artikelinhalt

• detach () syntax
• Threadname bei Global Scope
• Ablösung innerhalb des genannten Threads
• Abschluss

detach () syntax

Die Abnahme () -Syntax ist einfach; es ist:

ThreadObject.ablösen()

Diese Mitgliedsfunktion des Thread -Objekts gibt ungültig zurück. ThreadObject ist das Thread -Objekt des Threads, dessen Funktion ausgeführt wird. Wenn die Funktion eines Threads ausgeführt wird, wird der Thread als ausführender Thread bezeichnet.

Ein Thread kann erst nach dem verbundenen Anschluss abgelöst werden. Andernfalls befindet sich der Thread bereits im abgetrennten Zustand.

Mehrdeutigkeit des Ablösens in den Körper des Berufsfadens

Im folgenden Programm wird der angerufene Thread im Körper des Anruffadens abgelöst:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
String Globl = String ("auf der Erde!");
void func (String st)
String Fin = "Living" + st;
Cout <
int main ()

Thread thr (func, globl);
TH.verbinden();
TH.ablösen();
Rückkehr 0;

Die Ausgabe vom Computer des Autors zur Laufzeit war:

Auf Erden leben!
Beenden Sie nach dem Werfen einer Instanz von 'std :: system_error'
Was (): Ungültiges Argument
Abgebildet (Kerngeladen)

Die ordnungsgemäße Ausgabe sollte nur sein:

Auf Erden leben!

Wenn ein Thread seine Ausführung beendet, veröffentlicht die Implementierung alle Ressourcen, die er besaß. Wenn ein Thread verbunden ist, wartet der Körper des aufrufenden Threads an diesem Punkt, bis der angerufene Thread seine Ausführung abgeschlossen hat.

Das Problem der Anwesenheit der weiteren Ausgabe ist, dass der angerufene Thread zwar seine ihm gegebene Aufgabe erledigt hat, seine Ressourcen jedoch nicht alle weggenommen wurden, aber die Abnahme () -Funktion führte dazu, dass der Körper der Aufruffunktion weiter ausgeführt wurde. In Ermangelung der Funktion der Abnahme () hätte der angerufene Thread abgeschlossen und alle seine weggenommenen Ressourcen; und die Ausgabe wäre die einfache einzeilige erwartete Einstellung gewesen.

Um den Leser weiter zu überzeugen, betrachten Sie das folgende Programm, das dem oben genannten entspricht, jedoch mit den Aussagen von Join () und detach () kommentierte:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
String Globl = String ("auf der Erde!");
void func (String st)
String Fin = "Living" + st;
Cout <
int main ()

Thread thr (func, globl);
// Thr.verbinden();
// Thr.ablösen();
Rückkehr 0;

Die Ausgabe vom Computer des Autors lautet:

Beenden Sie ohne aktive Ausnahme bezeichnet
Abgebildet (Kerngeladen)

Die main () -Funktion lief bis zu ihrem Ende, ohne darauf zu warten, dass der Thread etwas tut. Und so konnte der Thread seine Ausgabe nicht anzeigen.

Threadname bei Global Scope

Ein Thread kann im globalen Bereich instanziiert werden. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
Faden Thr;
void func ()
Cout <<"the first line" <Cout <<"the second line" <
int main ()

Thr = Thread (func);
TH.verbinden();
Rückkehr 0;

Die Ausgabe ist:

die erste Zeile
die zweite Zeile

Vor der Funktion ist Func () im Programm definiert; Es gibt die Aussage,

Faden Thr;

welches den Thread instanziiert, Thr. Zu diesem Zeitpunkt hat Thr keine entsprechende Funktion. In der Funktion main () lautet die erste Anweisung::

Thr = Thread (func);

Die rechte Seite dieser Anweisung erstellt einen Thread ohne Namen und weist den Thread Variable THR den Thread zu. Auf diese Weise erwirbt TH eine Funktion. Die nächste Aussage verbindet sich dem angerufenen Thread.

Ablösung innerhalb des genannten Threads

Eine bessere Möglichkeit, einen Faden zu lösen, besteht darin, dies im Körper des genannten Fadens zu tun. In diesem Fall müsste das Thread -Objekt im globalen Bereich erstellt werden, wie oben dargestellt. Dann befindet sich die Abnahmemitteilung im Körper des genannten Faden. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
Faden Thr;
void func ()
Cout <<"the first line" <TH.ablösen();
Cout <<"the second line" <
int main ()

Thr = Thread (func);
TH.verbinden();
Cout <<"main() function line" <Rückkehr 0;

Die Ausgabe ist:

die erste Zeile
die zweite Zeile
Main () Funktionslinie

Zur Laufzeit wurde keine Fehlermeldung ausgegeben. Die Anweisung join () erwartete, dass der Thread ausgeführt werden soll. Dies geschah trotz der Tatsache, dass der angerufene Thread mitten in seiner Ausführung mit der Erklärung abgelöst wurde,

TH.ablösen();

Und so wurde die Main () -Funktion (Hauptfache) fortgesetzt, nachdem der angerufene Thread abgeschlossen war, wobei alle Ressourcen von der Implementierung veröffentlicht wurden. In der zweiten Hälfte des angerufenen Thread.

Das Programm beginnt mit der Aufnahme der iStream -Bibliothek für das Cout -Objekt. Als nächstes gibt es die Einbeziehung der Thread -Bibliothek, die ein Muss ist. Dann gibt es die Instanziierung des Threads, Thr, ohne eine Funktion. Die Funktion, die sie verwenden wird, wird kurz danach definiert. Diese Funktion hat die abgelöste Aussage des Objekts in seinem Körper.

Im Main () -Funktionskörper erstellt die erste Anweisung einen Faden einer Funktion, jedoch ohne Namen. Dieser Thread wird dann Thr zugewiesen. THR hat nun eine Funktion mit dem Vorteil, dass es im globalen Bereich geschaffen wurde, so dass es in func () zu sehen war.

Die nächste Anweisung verbindet sich der Funktionskörper der Funktion main () mit dem aufgerufenen Thread. Der Thread wurde in der ersten Aussage der Main () -Funktion aufgerufen. Zu diesem Zeitpunkt wartet der Haupt () -Funktionskörper darauf, dass der angerufene Thread bis zum Ende läuft und alle Ressourcen veröffentlicht wurden, obwohl er in seiner Mitte abgelöst wurde. Die Join () -Funktion erfüllt ihre Pflicht, solange alles im genannten Faden legitim ist.

Die Ausführung setzt sich mit der Hauptfunktion fort, nachdem der aufgerufene Thread wie erwartet erfolgreich beendet ist (wobei alle Ressourcen veröffentlicht wurden). Darum,

"Main () Funktionslinie"

wird nach allen Ausgängen des genannten Threads ausgegeben.

Abschluss

Wenn Sie einen Thread abnehmen, kann der aufgerufene Thread weiter ausgeführt werden, während der ihn genannte Thread auch weiter ausführen kann. Das heißt, der Anruffaden wartet nicht mehr weiter (Block), nachdem er sich angeschlossen hat. Dies kann die Geschwindigkeit beider Threads erhöhen, so dass sie parallel laufen und so die Geschwindigkeit des gesamten Programms erhöhen können. In diesem Fall ist es am besten, den Faden in seinem Körper zu lösen, wo die Kommunikation zwischen ihnen nicht mehr auftritt. Um dies zu erreichen, lassen Sie die Thread -Variable im globalen Bereich ohne seine Funktion erstellt werden. In der Funktion main () des C ++ -Programms kann ein anonymer Thread mit der von Interesse funktionen erstellt und der Thread -Variablen zugeordnet werden. Dieser Schritt ruft die Thread -Funktion auf und so den Thread auf.

Nach der Anweisung der Abnahme hat die Anweisung join () nicht mehr ihre normal. Es wird nicht empfohlen, den aufgerufenen Thread vom aufrufenden Thread abzunehmen.