Multithreading er en funksjon som tillater samtidig kjøring av to eller flere deler av et program for maksimal utnyttelse av CPU. Hver del av et slikt program kalles en tråd. Så, tråder er lette prosesser i en prosess.
java type variabel
Multithreading-støtte ble introdusert i C++11. Før C++11 måtte vi bruke POSIX-tråder eller bibliotek . Selv om dette biblioteket gjorde jobben, forårsaket mangelen på standardspråkleverte funksjoner alvorlige portabilitetsproblemer. C++ 11 gjorde unna alt dette og ga oss std::tråd . Trådklassene og relaterte funksjoner er definert i header-fil.
Syntaks:
std::thread thread_object (callable);>
std::tråd er trådklassen som representerer en enkelt tråd i C++. For å starte en tråd trenger vi ganske enkelt å lage et nytt trådobjekt og sende den utførende koden som skal kalles (dvs. et anropbart objekt) inn i konstruktøren av objektet. Når objektet er opprettet, startes en ny tråd som vil utføre koden spesifisert i callable. En anropbar kan være hvilken som helst av de fem:
- En funksjonspeker
- Et Lambda-uttrykk
- Et funksjonsobjekt
- Ikke-statisk medlemsfunksjon
- Statisk medlemsfunksjon
Etter å ha definert den anropbare, sender vi den til konstruktøren.
Starte tråd ved hjelp av funksjonspeker
En funksjonspeker kan være et anropbart objekt som skal sendes til std::thread-konstruktøren for initialisering av en tråd. Følgende kodebit viser hvordan det gjøres.
Eksempel:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Starte tråd ved hjelp av Lambda-uttrykk
std::thread-objekt kan også startes ved å bruke et lambda-uttrykk som callable. Følgende kodebit viser hvordan dette gjøres:
Eksempel:
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);> |
>
>
Starte tråd ved hjelp av funksjonsobjekter
Funksjonsobjekter eller funksjoner kan også brukes til å starte en tråd i C++. Følgende kodebit viser hvordan det gjøres:
Eksempel:
sjakal vs ulv
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)> |
>
>
Merk : Vi sender alltid parametere for den kallbare separat som argumenter til trådkonstruktøren.
Starte tråd ved hjelp av ikke-statisk medlemsfunksjon
Vi kan også starte tråden ved å bruke den ikke-statiske medlemsfunksjonen til en klasse. Følgende utdrag viser hvordan du gjør det.
C++
programvaretesting og -typer
// 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);> |
>
>
Starte tråd ved hjelp av statisk medlemsfunksjon
Vi kan også starte trådene ved å bruke statiske medlemsfunksjoner.
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);> |
>
programvaretesting og -typer
>
Venter på at trådene skal bli ferdige
Når en tråd har startet, kan det hende vi må vente til tråden er ferdig før vi kan gjøre noe. For eksempel, hvis vi tildeler oppgaven med å initialisere GUI-en til en applikasjon til en tråd, må vi vente til tråden er ferdig for å sikre at GUI-en har lastet inn riktig.
For å vente på en tråd, bruk std::thread::join() funksjon. Denne funksjonen får den gjeldende tråden til å vente til tråden identifiseres av *dette er ferdig utført.
For å blokkere hovedtråden til tråden t1 er ferdig, ville vi for eksempel gjort:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Et komplett C++-program for flertråding
Et C++-program er gitt nedenfor. Den lanserer tre tråder fra hovedfunksjonen. Hver tråd kalles ved å bruke et av de anropbare objektene spesifisert ovenfor.
java tostring-metoden
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; }> |
>
>
Utgang (maskinavhengig)
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>
Merk: For å kompilere programmer med std::thread-støtte, bruk g++ -std=c++11 -pthread.