Multithreading ir funkcija, kas ļauj vienlaikus izpildīt divas vai vairākas programmas daļas, lai maksimāli izmantotu centrālo procesoru. Katru šādas programmas daļu sauc par pavedienu. Tātad pavedieni ir viegli procesi procesa ietvaros.
java dinamiskais masīvs
Daudzpavedienu atbalsts tika ieviests programmā C++11. Pirms C++11 mums bija jāizmanto POSIX pavedieni vai bibliotēka . Lai gan šī bibliotēka paveica darbu, standarta valodas nodrošināto funkciju kopas trūkums radīja nopietnas pārnesamības problēmas. C++ 11 to visu atcēla un deva mums std::pavediens . Vītņu klases un saistītās funkcijas ir definētas galvenes fails.
Sintakse:
std::thread thread_object (callable);>
std::pavediens ir pavedienu klase, kas apzīmē vienu pavedienu valodā C++. Lai sāktu pavedienu, mums vienkārši ir jāizveido jauns pavediena objekts un jānodod izsaucamais izpildkods (t.i., izsaucams objekts) objekta konstruktoram. Kad objekts ir izveidots, tiek palaists jauns pavediens, kas izpildīs kodu, kas norādīts sadaļā Callable. Izsaucams var būt jebkurš no pieciem:
- Funkciju rādītājs
- Lambda izteiksme
- Funkciju objekts
- Nestatiskā dalībnieka funkcija
- Statiskā locekļa funkcija
Pēc izsaucamā definēšanas mēs to nododam konstruktoram.
Pavedienu palaišana, izmantojot funkciju rādītāju
Funkcijas rādītājs var būt izsaucams objekts, kas jānodod std::thread konstruktoram pavediena inicializācijai. Šis koda fragments parāda, kā tas tiek darīts.
Piemērs:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Pavediena palaišana, izmantojot Lambda izteiksmi
std::thread objektu var arī palaist, izmantojot lambda izteiksmi kā izsaucamo. Šis koda fragments parāda, kā tas tiek darīts:
Piemērs:
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);> |
>
>
Pavediena palaišana, izmantojot funkciju objektus
Funkciju objektus vai Funktorus var izmantot arī pavediena palaišanai programmā C++. Šis koda fragments parāda, kā tas tiek darīts:
Piemērs:
C++
java lambda
// 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)> |
>
>
Piezīme : Mēs vienmēr atsevišķi nododam izsaucamā parametrus kā argumentus pavedienu konstruktoram.
Pavediena palaišana, izmantojot nestatisko locekļu funkciju
Mēs varam arī palaist pavedienu, izmantojot klases nestatisko dalībnieka funkciju. Šis fragments parāda, kā to izdarīt.
C++
izņēmums mest java
// 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);> |
>
>
Pavediena palaišana, izmantojot statisko dalībnieka funkciju
Mēs varam arī palaist pavedienus, izmantojot statiskās dalībnieku funkcijas.
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);> |
>
kāds ir mana monitora izmērs
>
Gaida pavedienu pabeigšanu
Kad pavediens ir sācies, mums, iespējams, būs jāgaida, līdz pavediens beidzas, pirms mēs varam rīkoties. Piemēram, ja mēs piešķiram uzdevumu inicializēt lietojumprogrammas GUI pavedienam, mums jāgaida, līdz pavediens beidzas, lai nodrošinātu, ka GUI ir pareizi ielādēts.
Lai gaidītu pavedienu, izmantojiet std::thread::join() funkciju. Šī funkcija liek pašreizējam pavedienam gaidīt, līdz pavediens, kuru identificē ar *šis ir pabeidzis izpildi.
Piemēram, lai bloķētu galveno pavedienu, līdz pavediens t1 ir beidzies, mēs rīkojamies šādi:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Pilnīga C++ programma daudzpavedienu veidošanai
C++ programma ir dota zemāk. Tas palaiž trīs pavedienus no galvenās funkcijas. Katrs pavediens tiek izsaukts, izmantojot vienu no iepriekš norādītajiem izsaucamajiem objektiem.
C++
romiešu cipari 1100
// 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; }> |
>
>
Izvade (atkarīga no mašīnas)
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>
Piezīme: Lai kompilētu programmas ar std::thread atbalstu, izmantojiet g++ -std=c++11 -pthread.