Multithreading is een functie die gelijktijdige uitvoering van twee of meer delen van een programma mogelijk maakt voor maximaal gebruik van de CPU. Elk deel van zo'n programma wordt een thread genoemd. Threads zijn dus lichtgewicht processen binnen een proces.
zweven naar touw
Ondersteuning voor multithreading werd geïntroduceerd in C++11. Vóór C++11 moesten we gebruiken POSIX-threads of bibliotheek . Hoewel deze bibliotheek zijn werk deed, veroorzaakte het ontbreken van een door de standaard taal geleverde functieset ernstige portabiliteitsproblemen. C++ 11 heeft dat allemaal afgeschaft en ons gegeven std::draad . De threadklassen en gerelateerde functies worden gedefinieerd in het header-bestand.
Syntaxis:
std::thread thread_object (callable);>
std::draad is de threadklasse die een enkele thread in C++ vertegenwoordigt. Om een thread te starten hoeven we alleen maar een nieuw threadobject te maken en de aan te roepen uitvoeringscode (dat wil zeggen een opvraagbaar object) door te geven aan de constructor van het object. Zodra het object is gemaakt, wordt een nieuwe thread gelanceerd die de code uitvoert die is opgegeven in callable. Een callable kan een van de vijf zijn:
- Een functieaanwijzer
- Een Lambda-expressie
- Een functieobject
- Niet-statische ledenfunctie
- Statische lidfunctie
Nadat we de callable hebben gedefinieerd, geven we deze door aan de constructor.
Thread starten met behulp van de functieaanwijzer
Een functieaanwijzer kan een opvraagbaar object zijn dat moet worden doorgegeven aan de std::thread-constructor voor het initialiseren van een thread. Het volgende codefragment laat zien hoe dit wordt gedaan.
Voorbeeld:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Thread starten met Lambda-expressie
std::thread-object kan ook worden gestart met behulp van een lambda-expressie als opvraagbaar object. Het volgende codefragment laat zien hoe dit wordt gedaan:
Voorbeeld:
C++
jasmijn davis als kind
// Define a lambda expression> auto> f = [](params)> {> >Statements;> };> // Pass f and its parameters to thread> // object constructor as> std::>thread> thread_object(f, params);> |
>
>
Thread starten met behulp van functieobjecten
Functieobjecten of Functors kunnen ook worden gebruikt voor het starten van een thread in C++. Het volgende codefragment laat zien hoe dit wordt gedaan:
Voorbeeld:
C++
// 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)> |
>
>
Opmerking : We geven parameters van het opvraagbare altijd afzonderlijk door als argumenten aan de threadconstructor.
Thread starten met behulp van de niet-statische ledenfunctie
We kunnen de thread ook starten met behulp van de niet-statische lidfunctie van een klasse. Het volgende fragment laat zien hoe u dit kunt doen.
C++
wat is 10 van de 100
// 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 starten met behulp van de statische ledenfunctie
We kunnen de threads ook starten met behulp van statische lidfuncties.
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);> |
>
willekeurig getal gen java
>
Wachten tot de threads klaar zijn
Zodra een thread is gestart, moeten we mogelijk wachten tot de thread is afgelopen voordat we actie kunnen ondernemen. Als we bijvoorbeeld de taak van het initialiseren van de GUI van een applicatie aan een thread toewijzen, moeten we wachten tot de thread is voltooid om er zeker van te zijn dat de GUI correct is geladen.
Om op een thread te wachten, gebruikt u de std::thread::join() functie. Deze functie zorgt ervoor dat de huidige thread wacht totdat de thread wordt geïdentificeerd door *dit is klaar met uitvoeren.
Om bijvoorbeeld de hoofdthread te blokkeren totdat thread t1 is afgelopen, doen we het volgende:
C++
Hoe een geheel getal naar een string in Java te converteren
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Een compleet C++-programma voor multithreading
Hieronder vindt u een C++-programma. Het lanceert drie threads vanuit de hoofdfunctie. Elke thread wordt aangeroepen met behulp van een van de hierboven gespecificeerde opvraagbare objecten.
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; }> |
>
>
Uitvoer (machine-afhankelijk)
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>
Opmerking: Om programma's te compileren met std::thread-ondersteuning gebruik je g++ -std=c++11 -pthread.