Multithreading in C++ ist eine Funktion, die es ermöglicht, mehrere Aufgaben gleichzeitig und gleichzeitig auszuführen. Ein Thread ist die Arbeitseinheit eines bestimmten Prozesses, der ausgeführt wird. Zahlreiche Threads werden unabhängig voneinander gleichzeitig ausgeführt, um Multithreading durchzuführen.
So implementieren Sie Multithreading in C++
Ein Multithread-Programm besteht aus zwei oder mehr Teilen, die dazu neigen, gleichzeitig ausgeführt zu werden. Jeder Teil wird als Thread bezeichnet und hat einen anderen Ausführungspfad. Zahlreiche Threads werden unabhängig voneinander gleichzeitig ausgeführt, um Multithreading durchzuführen.
Voraussetzungen für Multithreading in C++
Unter Windows können Funktionen im Zusammenhang mit Threads in C++ 11 und erweiterten Versionen ausgeführt werden. Bei Verwendung des Dev-C++-Compilers ist er standardmäßig auf der C++ 3-Version, daher muss er manuell auf die C++ 11-Version umgestellt werden. Die GNU C++11-Umgebung kann durch Ändern der Sprachstandardeinstellungen ausgewählt werden.
Öffnen Sie den Dev-C++-Compiler und gehen Sie in der Taskleiste auf „Extras“. Wählen Sie „Compiler-Optionen“ und dann „Einstellungen“. Klicken Sie auf den Block „Codegenerierung“. Eine Liste der Befehle wird angezeigt. Wählen Sie GNU C++11 unter „Language Standard(-std)“ aus und klicken Sie dann auf OK. Jetzt ist dieser Compiler bereit, Thread-Operationen zu unterstützen.
Laden Sie die Bibliotheken von GitHub herunter und platzieren Sie sie im lib-Ordner des Cpp-Compilers. Rufen Sie diese Bibliotheken im Programm mit #include „mingw.thread.h“ und
std::thread thread_object ( abrufbar ) ;
Der std::thread wird von der Header-Datei #include „mingw.thread.h“ in C++11 unterstützt. Es ist eine Thread-Klasse und repräsentiert einen einzelnen Thread. Mit std::thread wird ein neuer Thread erstellt und ein Callable an ihn übergeben. Callable ist ein ausführbarer Code, der ausgeführt wird, wenn der Thread ausgeführt wird. Callable kann einer der drei unten aufgeführten Typen sein:
Wenn ein Objekt erstellt wird, startet es einen neuen Thread, der den Code im Callable ausführt.
Starten eines Threads mithilfe eines Funktionsobjekts
Ein Funktionsobjekt kann als aufrufbares Objekt zum Starten des Threads verwendet werden. Der Überladungsoperator () macht es aufrufbar:
Klasse function_object_class {Void-Operator ( ) ( Parameter )
{
Aussagen;
}
}
std::thread thread_object ( function_object_class ( ) , Parameter )
Die Überladungsfunktion wird dem Konstruktor als erstes Objekt und Anweisungen als zweites Objekt bereitgestellt.
Starten eines Threads mit Funktionszeiger
Ein Funktionszeiger wird definiert und dann als aufrufbares Element zum Starten eines Threads verwendet:
void function_call ( param ){
Aussagen;
}
std::thread thread_obj ( Funktionsaufruf, Parameter ) ;
Zu übergebende Argumente werden nach dem Namen der Funktion geschrieben.
Starten des Threads mit Lambda Expression
Das Thread-Objekt kann mit Lambda als Callable gestartet werden.
// Definieren Sie einen Lambda-Ausdruckauto f = [ ] ( Parameter )
{
Aussagen;
} ;
std::thread thread_object ( f, Parameter ) ;
Der Lambda-Ausdruck wird definiert und die darin enthaltenen Parameter werden aufgerufen, um den Thread zu starten.
In manchen Fällen muss der Thread angehalten werden, bevor er mit der Ausführung des nächsten Befehls beginnt. Der std::thread::join () Die Funktion wird verwendet, um auf das Ende des Threads zu warten. Wenn wir beispielsweise dem Thread eine GUI-Aufgabe zuweisen, müssen wir zunächst auf die Endzeit warten, um die GUI ordnungsgemäß zu laden, und dann würde der nächste Befehl ausgeführt werden.
int main ( ){
std::thread t1 ( abrufbar ) ;
t1.join ( ) ;
Aussagen;
}
Beispiel
Dies ist ein Programm, das zum Durchführen von Multithreading unter Verwendung aller drei aufrufbaren Elemente ausgeführt wird. Drei verschiedene Callables führen ihre jeweiligen Befehle dreimal gleichzeitig aus, ohne dass sie voneinander unterbrochen werden:
#include#include
Verwenden des Namensraums std;
void foo ( int Z )
{
für ( int i = 0 ; ich < Z; i++ ) {
cout << „Thread mit Funktion“
'Zeiger als aufrufbar \N ' ;
}
}
Klasse thread_obj {
öffentlich:
Void-Operator ( ) ( int x )
{
für ( int i = 0 ; ich < X; i++ )
cout << „Thread mit Funktion“
' Objekt als aufrufbar \N ' ;
}
} ;
// Haupt code
int main ( )
{
cout << „Threads 1 und 2 und 3“
„Selbstständig agieren“
<< endl;
Thread th1 ( foo, 3 ) ;
Thread th2 ( thread_obj ( ) , 3 ) ;
auto f = [ ] ( int x ) {
für ( int i = 0 ; ich < X; i++ )
cout << „Thread mit Lambda“
' Ausdruck als aufrufbar \N ' ;
} ;
Thread th3 ( F, 3 ) ;
th1.join ( ) ;
th2.join ( ) ;
th3.join ( ) ;
zurückkehren 0 ;
}
In diesem Programm werden die drei aufrufbaren Elemente, einschließlich Funktionszeiger, Funktionsobjekt und Lambda-Ausdruck, verwendet, um die drei Threads gleichzeitig zu starten. Die Threads 1, 2 und 3 geben ihre Werte gleichzeitig und unabhängig voneinander aus, ohne dass sie voneinander unterbrochen werden. Sie drucken ihre Werte dreimal aus. Die Funktion „join()“ wird verwendet, um auf das Ende des Threads zu warten.
Die Ausgaben aller drei Threads werden unabhängig voneinander angezeigt und dreimal wiederholt. Jeder Thread wartet darauf, dass der andere zuerst endet.
Abschluss
Multithreading in C++ ist eine Funktion, die es ermöglicht, mehrere Aufgaben gleichzeitig und gleichzeitig auszuführen. Das Multithread-Programm verfügt über zwei oder mehr Abschnitte, die gleichzeitig ausgeführt werden können. Jeder Teil wird als Thread bezeichnet und verfügt über einen separaten Pfad zur Ausführung. Es gibt drei aufrufbare Threads zum Starten: Funktionszeiger, Funktionsobjekte und Lambda-Ausdrücke. Diese ermöglichen das Multithreading.