Der einzelne Sequenzstrom eines Prozesses kann als Thread bezeichnet werden. Themen werden häufig als „leichte Prozesse“ bezeichnet, da sie einige Eigenschaften mit Prozessen aufweisen. Eine Klasse soll unterschiedliche Ausführungs -Threads darstellen. Ein einzelner Ausführungsthread wird durch den Klassen -Thread dargestellt. Mehrere Funktionen können aufgrund von Threads gleichzeitig ausgeführt werden. Wenn ein Thread -Objekt erstellt wird, beginnt es sofort mit der Ausführung (vorbehaltlich der OS -Planungsverzögerungen), beginnend mit der höchsten als Funktionskonstruktor angegebenen Funktion. Der definierte Wert der Methode wird nicht berücksichtigt und std :: terminate wird aufgerufen, wenn er durch Erhöhen eines Fehlers ausgeht.

Arten von Fäden

Der spezielle Serienstrom eines Prozesses wird als Thread bezeichnet. Themen werden als unmenschliche Verfahren bezeichnet, da sie in vielerlei Hinsicht den Prozessen ähnlich sind. Obwohl Threads nacheinander betrieben werden, scheinen sie gleichzeitig gleichzeitig ausgeführt zu werden. Für jeden Thread gibt es verschiedene Zustände.

• ein elektronischer Zähler
• eine Reihe von Registern
• ein Regalbereich

Prozesse

Im Wesentlichen sind Prozesse die Programme, die aus dem Ready State entsandt und für die Ausführung in der CPU geplant sind. Das Prozesskonzept wird von PCB (Process Control Block) gehalten. Ein Prozess kann so produzieren, was als „Kinderprozesse“ oder neue Prozesse bezeichnet wird. Der Vorgang dauert länger, da er isoliert ist, was bedeutet, dass er keinen Speicher mit anderen Prozessen freigibt. Jeder der folgenden Zustände für den Prozess könnte vorhanden sein: neu, bereit, laufend, warten, gekündigt oder suspendiert.

Themen

Ein Thread ist ein Modul eines Prozesses. Ein Prozess kann mehrere Threads haben und alle diese Threads sind innerhalb der Methode enthalten. Drei Zustände existieren für einen Thread: Laufen, Bereit und blockiert. Der Faden endet schneller als der Prozess, isoliert jedoch nicht wie der Prozess.

Die gemeinsamen Eigenschaften zwischen Fäden und Prozessen umfassen

• Nur ein Thread oder Prozess kann gleichzeitig operativ sein.
• Aufeinanderfolgende Ausführung innerhalb des Prozesses.
• Die Fähigkeit, Kinder zu erzeugen.

Die Unterscheidungen zwischen Prozessen und Faden

• Prozesse sind selbstregulierend; Themen sind nicht.
• Während sich die Prozesse gegenseitig helfen oder nicht, sind Threads dazu entwickelt, dies zu tun.

Thread auf Benutzerebene

Es wird in der Bibliothek auf Benutzerebene in die Praxis umgesetzt. Systemaufrufe werden nicht verwendet, um sie zu konstruieren. Das Thread -Switing erfordert keinen Betriebssystemaufruf oder einen Kernel -Interrupt. Der Kernel verwaltet sie so, als wären sie mit Single-Threaden-Prozessen, da er sich des Threads auf Benutzerebene nicht bewusst ist.

Vorteile

• Die einzigen Attribute, die ein Thread hat, sind ein Stapelraum, ein Stapelzeiger und ein Schaltregister.
• Da der Kernel keine Anpassungen vornimmt, ist die Erstellung einfach.
• Aufgrund des Fehlens von OS -Aufrufen ist das Thread -Switching schnell.
• Es ist mit Betriebssystemen kompatibel, die Multi-Threading verbieten.

Ein Thread auf Kernelebene

Die Themen werden vom Kernel verwaltet. Darüber hinaus verfolgt der Kernel auch die Prozesse mithilfe der herkömmlichen Prozess Tabelle. Der OS -Kernel verfügt über Systemaufrufe zum Verwalten und Erstellen von Threads.

Vorteile

• Angesichts der Tatsache, dass der Kernel vollständige Informationen über die Threads des Systems hat.
• Der Scheduler kann sich entscheiden, Prozesse mit einer hohen Anzahl von Threads zusätzliche Zeit zu geben.
• Gut, um Programme regelmäßig zu blockieren.

Multi-Threading:

Ein anderer Name für einen Thread ist ein leichter Prozess. Durch die Aufschlüsselung eines Prozesses in mehrere Fäden soll die Parallelität erreicht werden. Zum Beispiel könnten viele Registerkarten in einem Browser verschiedene Threads darstellen. Mehrere Threads werden von MS Word verwendet, einschließlich eines für die Verarbeitung von Eingaben und eine für die Formatierung des Textes.

Definieren Sie eine Funktion thread ()

Ein Klassen -Thread bezieht sich auf einen bestimmten Implementierungsfaden. In C ++ bezieht sich der Begriff „Thread -Klasse“ auf die STD :: Thread -Klasse. Sobald das verknüpfte Threads-Objekt erstellt wurde, ist die oberste Methode, die als Teil der Funktionskonstruktorvereinbarung bereitgestellt wurde. Der implementierende Code, der aufgerufen werden muss.

Wie bereits erwähnt, ist STD :: Thread erforderlich, um einen neuen Thread zu starten, und der Thread muss auch aufrufbar sein. Ein Anruf ist ein Programm, das ausgeführt werden muss, wenn der Thread aktiv ist. Mit anderen Worten, wenn ein neuer Thread erforderlich ist, muss ein Anrufabstand als Argument an den Konstruktor eines Objekts für Std :: Thread geliefert werden. Danach beginnt der neu erzeugte Thread und die aufrufbare Funktion wird ausgeführt.

Prozesse gegen Threads

Die Hauptunterscheidung ist, dass Prozesse, die in verschiedenen Speicherbereichen ausgeführt werden, Fäden in einem einzelnen prozess gemeinsam genutzten Speicherplatz. Da Themen nicht vollständig unabhängig voneinander sind wie Prozesse, teilen sie ihre OS -Ressourcen, den Abschnitt und den Datenabschnitt mit anderen Threads.

Themen haben Vorteile gegenüber Prozessen

• Reaktionsfähigkeit: Wenn ein Prozess in zahlreiche Threads unterteilt ist, kann die Ausgabe jedes Threads zurückgegeben werden, sobald er ausgeführt wurde.
• Schneller Kontextschalter: Kontextschalter zwischen Threads erfolgen schneller als Kontextschalter innerhalb eines Prozesses. Die CPU muss aufgrund von Prozesskontextverschiebungen mehr Gemeinkosten durchführen.
• Effektives Multiprozessor -System Verwendung: Wenn ein Prozess viele Threads enthält, können wir diese Threads auf verschiedenen Prozessoren planen. Infolgedessen wäre es eine schnellere Prozessausführung.
• Die Kommunikation wird durch die Tatsache erleichtert, dass mehrere Themen einen Adressraum teilen. Während wir im Bearbeitung sind, müssen wir uns an eine bestimmte Kommunikationsmethode für die Kommunikation mit zwei Prozess halten.
• Ressourcenfreigabe: Alle Themen in einem Prozess können Ressourcen wie Code, Daten und Dateien freigeben.
• Steigerung der Systemkapazität: Wenn eine Aufgabe in mehrere Threads unterteilt ist, wird jeder Thread -Betrieb als Funktion behandelt, und erhöht die Anzahl der in einer bestimmten Zeitmenge durchgeführten Methoden die Systemkapazität.

Fadenfunktion in c++

In einem Betriebssystem bieten sie (POSIX -Thread) für Funktionen, diese Funktionen im Zusammenhang mit Funktionen. Wir können viele Threads auf diese Weise machen, um den gleichzeitigen Prozessfluss zu unterstützen. Es funktioniert am besten auf Systemen mit mehreren Prozessoren oder Kernen, bei denen die Ausführungsgeschwindigkeit erreicht werden kann, indem Threads auf Kernelebene implementiert werden. Gewinne können auch in Systemen mit einem einzigen Prozessor erzielt werden.

Erstellen () Funktionen

pthread_create: neuer Thread erstellen

Parameter

• Thread: Ein Zeiger auf einen nicht signierten Ganzzahlwert, der die Thread -ID des neuesten Threads enthält, der begonnen wurde.
• Attr: Attribute eines Threads, wie z., werden durch eine Struktur namens Attr. Für Standard -Thread -Eigenschaften auf null gesetzt.
• Startroutine: Ein Zeiger auf das Startunterroutine eines Threads. Die Funktion hat nur ein Attribut, aber es muss eine Struktur verwendet werden, wenn mehr als ein Wert an die Funktion geliefert werden muss.
• ARG: Ein Zeiger auf eine Hohlraum.

Exit () Funktion

pthread_exit: Wird verwendet, um die Verwendung eines Threads zu stoppen

Parameter
Enthüllen Sie, ein Zeiger auf eine Ganzzahl, die den Rückgabestatus des Threads enthält. Jeder Thread, der darauf wartet, diesen Thread zu verbinden.

Join () Funktion

pthread_join: Wird verwendet, um das Warten des Fadens zu verlassen

Parameter

• TH: Der Thread wartet auf die Kennung des Threads.
• Thread -Rückgabe: Ein Zeiger auf den Ort, an dem der im Exit -Status beschriebene Thread gespeichert wird.

Equal () Funktion

pthread_equal: Bestimmt, ob zwei Threads ähnlich sind oder nicht. Die Funktion gibt eine Zahl ungleich Null zurück, wenn die beiden Threads gleich sind, sonst Null.

St :: Fadenerstellung

In C ++ werden Threads mit der STD :: Thread -Klasse erstellt. Ein Thread ist ein einzigartiger Ausführungsfluss; Es ist ähnlich wie eine Helfer, die eine Aufgabe erledigt, während Sie eine andere gleichzeitig beenden. Sobald der gesamte Code des Threads ausgeführt wurde, stoppt er. Bei der Einrichtung eines Threads muss etwas übergeben werden, um darauf ausgeführt zu werden. Die unten aufgeführten Objekte können an einen Thread übergeben werden.

Mitgliedstypen

ID: Thread ID (öffentlich)
Native_handle_type: native_handle_type (public)

Der Thread ermöglicht die gleichzeitige Ausführung mehrerer Aufgaben. In C ++ bezieht sich der Begriff „Thread -Klasse“ auf die STD :: Thread -Klasse. Ein neues Thread -Objekt muss generiert werden, um einen Thread zu starten, und es muss an den ausführenden Code geliefert werden, der aufgerufen werden muss. Die obere Methode, die als Teil der Funktionskonstruktorvereinbarung geliefert wurde.

Callable verwenden Objekt

Ein Objekt könnte durch die Verwendung dieser Methode abgerufen werden. Dazu ist eine Klasse erforderlich und Operator () muss innerhalb dieser Klasse überladen sein. Die Software, die ausgeführt wird, wenn der Thread gebildet wird, ist in den überlasteten Methoden enthalten.

Nutzbar mit Zeiger

Ein Zeiger wird mit dieser Methode abrufbar gemacht. Im Thread -Objekt wird die an die Methode gesendete Liste der Parameter oder Argumente neben dem Namen der Funktion angezeigt.

Mit Funktionszeiger aufgerufen

Das Geben des Thread -Objekts zur Ausführung erzielt das gewünschte Ergebnis. Der Funktionskonstruktor des Thread -Objekts empfängt einen Lambda -Ausdruck mit dem Namen „LM“ als erstes Argument, bevor er seine Argumente als zweites Argument erhält.

Lassen Sie uns verschiedene Beispiele für STD :: Thread -Funktionen diskutieren.

Beispiel 1

In diesem Fall werden wir einen Thread mit einem Zeiger verwenden.

#enthalten
#enthalten
Klassentest

öffentlich:
void execute (STD :: String -Befehl)

für (int i = 0; i < 8; i++)

std :: Cout<

;
int main ()

Test * testPtr = neuer Test ();
std :: thread th (& test :: execute, testPtr, "Werte");
th.verbinden();
Testptr löschen;
Rückkehr 0;

Zunächst geben wir die Headers -Dateien und in das Programm ein. Wir erstellen die Klasse und geben ihren Namen "Test" an. Dann verwenden wir die öffentliche Methode und führen den String -Befehl aus. Nach Ausführung des String -Befehls bewerben wir uns für Schleife und Inkrement (0 bis 8). Hier verwenden wir die Cout -Erklärung. Als nächstes nennen wir die main () -Funktion. Zusammen mit diesem nennen wir die Klasse "Test" und verwenden einen Zeiger darin. Als nächstes passt der Thread den Zeiger über. Anschließend haben wir die Funktion join () verwendet, den Testzeiger löschen und 'return 0' eingeben.

Beispiel 2

In diesem Fall werden wir einen Thread ohne Zeiger verwenden.

#enthalten
#enthalten
Klassenname

öffentlich:
Statischer Hohlraumtest (STD :: String -Befehl)

für (int i = 0; i < 3; i++)

std :: Cout<

;
int main ()

std :: thread th (& name :: test, "name");
th.verbinden();
Rückkehr 0;

Verwenden Sie Header -Dateien und . Erstellen Sie eine Klasse und der Titel der Klasse lautet "Name". Wir verwenden die öffentliche Methode und die nächste Zeile verwendet eine statische Mitgliedsfunktion und hier übergeben die Zeichenfolge. Verwenden Sie die "für" Schleife und initialisieren Sie die Werte von 0 bis 3. Die Anweisung "Cout" wird verwendet, um den Wert darzustellen. In der nächsten Zeile rufen wir die Funktion main () auf, verwenden Thread und übergeben die Werte, ohne einen Zeiger zu verwenden. Als nächstes verwenden wir die Funktion join () und geben 'return 0' ein.

Beispiel 3

Hier werden wir den Leeroperator anwenden.

#enthalten
#enthalten
Verwenden von Namespace STD;
Klassenlabor
öffentlich:
void operator () (int a)

für (int i = 0; i < a; i++)
Cout << "Number of threads :" << i << "\n";

;
int main ()

Thread T2 (Lab (), 6);
t2.verbinden();
Rückkehr 0;

In diesem Code integrieren wir die erforderlichen Header -Dateien , . Wir verwenden den Standard -Namespace als STD. Wir fügen eine Klasse namens "Lab" hinzu und verwenden seine öffentliche Methode. Verwenden Sie dann den Hohlraumoperator und initialisieren Sie eine Variable 'a' darin. Hier werden wir die 'für' Schleife von 0 zum Wert der Variablen 'a' verwenden. Darüber hinaus werden wir eine Anweisung „Anzahl der Threads“ mit der Anweisung "Cout" ausdrucken. Wir berufen die Main () -Funktion. In diesem Fall wird ein Thread mit dem Wert 6 deklariert. Wenn ein Thread einen Anruf erhält, wird ein Code ausgeführt und die Nachricht auf dem Bildschirm angezeigt.

Abschluss

In diesem Handbuch haben wir über den Thread in C ++ - Funktionen gesprochen. Dann beobachten wir verschiedene Funktionen von Thread in C++. Wir haben den Thread und auch seine Typen definiert. Außerdem haben wir verschiedene Parameter des Threads erwähnt. Wir haben zahlreiche Arten von Codes ausgeführt. Im ersten Code haben wir einen Thread mit einem Zeiger verwendet. Es handelt sich um eine nicht statische Mitgliedsfunktion. Zweitens, in Code verwenden wir Thread ohne Zeiger, es handelt sich um eine statische Mitgliedsfunktion. Dritter und letzter Code haben wir den Hohlraumoperator verwendet und als ein Thread den Wert erhielt, zeigte er die Nachricht auf dem Bildschirm.