Multithreading ist eine Funktion, die die gleichzeitige Ausführung von zwei oder mehr Teilen eines Programms zur maximalen Auslastung der CPU ermöglicht. Jeder Teil eines solchen Programms wird als Thread bezeichnet. Threads sind also leichtgewichtige Prozesse innerhalb eines Prozesses.
Name von
Multithreading-Unterstützung wurde in C++11 eingeführt. Vor C++11 mussten wir verwenden POSIX-Threads oder Bibliothek . Während diese Bibliothek ihre Aufgabe erfüllte, verursachte das Fehlen eines von der Standardsprache bereitgestellten Funktionsumfangs ernsthafte Portabilitätsprobleme. C++ 11 hat all das abgeschafft und uns gegeben std::thread . Die Thread-Klassen und zugehörigen Funktionen sind in definiert Header-Datei.
Syntax:
std::thread thread_object (callable);>
std::thread ist die Thread-Klasse, die einen einzelnen Thread in C++ darstellt. Um einen Thread zu starten, müssen wir lediglich ein neues Thread-Objekt erstellen und den aufzurufenden ausführenden Code (d. h. ein aufrufbares Objekt) an den Konstruktor des Objekts übergeben. Sobald das Objekt erstellt wurde, wird ein neuer Thread gestartet, der den in callable angegebenen Code ausführt. Ein Callable kann einer der fünf folgenden sein:
- Ein Funktionszeiger
- Ein Lambda-Ausdruck
- Ein Funktionsobjekt
- Nichtstatische Memberfunktion
- Statische Memberfunktion
Nachdem wir das Callable definiert haben, übergeben wir es an den Konstruktor.
Thread mit Funktionszeiger starten
Ein Funktionszeiger kann ein aufrufbares Objekt sein, das zum Initialisieren eines Threads an den std::thread-Konstruktor übergeben wird. Der folgende Codeausschnitt zeigt, wie es geht.
Beispiel:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Thread mit Lambda-Ausdruck starten
Das std::thread-Objekt kann auch mit einem Lambda-Ausdruck als aufrufbares Objekt gestartet werden. Der folgende Codeausschnitt zeigt, wie das geht:
Beispiel:
C++
// Define a lambda expression> auto> f = [](params)> {> >Statements;> };> // Pass f and its parameters to thread> // object constructor as> std::>thread> thread_object(f, params);> |
img CSS ausrichten
>
>
Starten eines Threads mithilfe von Funktionsobjekten
Funktionsobjekte oder Funktoren können auch zum Starten eines Threads in C++ verwendet werden. Der folgende Codeausschnitt zeigt, wie es geht:
Beispiel:
C++
Escape-Zeichen Java
// Define the class of function object> class> fn_object_class {> >// Overload () operator> >void> operator()(params)> >{> >Statements;> >}> }> // Create thread object> std::>thread> thread_object(fn_object_class(), params)> |
>
>
Notiz : Wir übergeben Parameter des Callable immer separat als Argumente an den Thread-Konstruktor.
Starten eines Threads mithilfe einer nicht-statischen Member-Funktion
Wir können den Thread auch mithilfe der nicht statischen Memberfunktion einer Klasse starten. Der folgende Ausschnitt zeigt, wie es geht.
C++
// defining clasc> class> Base {> public>:> >// non-static member function> >void> foo(param) { Statements; }> }> // object of Base Class> Base b;> // first parameter is the reference to the functionn> // and second paramter is reference of the object> // at last we have arguments> std::>thread> thread_obj(&Base::foo, &b, params);> |
>
>
Thread mit statischer Member-Funktion starten
Wir können die Threads auch mithilfe statischer Memberfunktionen starten.
C++
// defining class> class> Base {> public>:> >// static member function> >static> void> foo(param) { Statements; }> }> // object of Base Class> Base b;> // first parameter is the reference to the function> // and rest are arguments> std::>thread> thread_obj(&Base::foo, params);> |
>
jframe
>
Warten auf das Ende der Threads
Sobald ein Thread gestartet ist, müssen wir möglicherweise warten, bis der Thread beendet ist, bevor wir Maßnahmen ergreifen können. Wenn wir beispielsweise die Aufgabe, die GUI einer Anwendung zu initialisieren, einem Thread zuweisen, müssen wir warten, bis der Thread beendet ist, um sicherzustellen, dass die GUI ordnungsgemäß geladen wurde.
Um auf einen Thread zu warten, verwenden Sie die std::thread::join() Funktion. Diese Funktion lässt den aktuellen Thread warten, bis der Thread identifiziert wird *Das ist mit der Ausführung fertig.
Um beispielsweise den Hauptthread zu blockieren, bis Thread t1 beendet ist, würden wir Folgendes tun:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
Zahl zum String Java
>
>
Ein vollständiges C++-Programm für Multithreading
Nachfolgend finden Sie ein C++-Programm. Es startet drei Threads von der Hauptfunktion aus. Jeder Thread wird mit einem der oben angegebenen aufrufbaren Objekte aufgerufen.
C++
// C++ program to demonstrate> // multithreading using three> // different callables.> #include> #include> using> namespace> std;> // A dummy function> void> foo(>int> Z)> {> >for> (>int> i = 0; i cout << 'Thread using function' ' pointer as callable
'; } } // A callable object class thread_obj { public: void operator()(int x) { for (int i = 0; i cout << 'Thread using function' ' object as callable
'; } }; // class definition class Base { public: // non-static member function void foo() { cout << 'Thread using non-static member function ' 'as callable' << endl; } // static member function static void foo1() { cout << 'Thread using static member function as ' 'callable' << endl; } }; // Driver code int main() { cout << 'Threads 1 and 2 and 3 ' 'operating independently' << endl; // This thread is launched by using // function pointer as callable thread th1(foo, 3); // This thread is launched by using // function object as callable thread th2(thread_obj(), 3); // Define a Lambda Expression auto f = [](int x) { for (int i = 0; i cout << 'Thread using lambda' ' expression as callable
'; }; // This thread is launched by using // lambda expression as callable thread th3(f, 3); // object of Base Class Base b; thread th4(&Base::foo, &b); thread th5(&Base::foo1); // Wait for the threads to finish // Wait for thread t1 to finish th1.join(); // Wait for thread t2 to finish th2.join(); // Wait for thread t3 to finish th3.join(); // Wait for thread t4 to finish th4.join(); // Wait for thread t5 to finish th5.join(); return 0; }> |
>
>
Ausgabe (maschinenabhängig)
Threads 1 and 2 and 3 operating independently Thread using function pointer as callable Thread using function pointer as callable Thread using function pointer as callable Thread using non-static member function as callable Thread using function object as callable Thread using function object as callable Thread using function object as callable Thread using lambda expression as callable Thread using lambda expression as callable Thread using lambda expression as callable Thread using static member function as callable>
Notiz: Um Programme mit std::thread-Unterstützung zu kompilieren, verwenden Sie g++ -std=c++11 -pthread.