Multithreading yra funkcija, leidžianti vienu metu vykdyti dvi ar daugiau programos dalių, kad būtų maksimaliai išnaudotas CPU. Kiekviena tokios programos dalis vadinama gija. Taigi, siūlai yra lengvi procesai procese.
komandą touch Linux sistemoje
Kelių gijų palaikymas buvo pristatytas C++11. Prieš C++11 turėjome naudoti POSIX gijos arba biblioteka . Nors ši biblioteka atliko savo darbą, standartinės kalbos teikiamų funkcijų rinkinio nebuvimas sukėlė rimtų perkeliamumo problemų. C++ 11 atsisakė viso to ir davė mums std::gija . Gijų klasės ir susijusios funkcijos yra apibrėžtos antraštės failą.
Sintaksė:
std::thread thread_object (callable);>
std::gija yra gijos klasė, kuri reiškia vieną giją C++. Norėdami pradėti giją, tiesiog turime sukurti naują gijos objektą ir perduoti vykdomąjį kodą, kuris turi būti iškviestas (ty iškviečiamą objektą) objekto konstruktoriui. Sukūrus objektą, paleidžiama nauja gija, kuri vykdys kodą, nurodytą iškviečiamas. Iškviečiamas gali būti bet kuris iš penkių:
- Funkcinis rodyklė
- Lambda išraiška
- Funkcinis objektas
- Nestatinė nario funkcija
- Statinė nario funkcija
Apibrėžę skambinamąjį, perduodame jį konstruktoriui.
Thread paleidimas naudojant funkcijos žymeklį
Funkcijų rodyklė gali būti iškviečiamas objektas, perduodamas std::thread konstruktoriui gijai inicijuoti. Šis kodo fragmentas parodo, kaip tai daroma.
Pavyzdys:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Gijos paleidimas naudojant Lambda išraišką
std::thread objektas taip pat gali būti paleistas naudojant lambda išraišką kaip skambutį. Šis kodo fragmentas parodo, kaip tai daroma:
Pavyzdys:
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);> |
dekoduoti base64 javascript
>
>
Gijos paleidimas naudojant funkcinius objektus
Funkciniai objektai arba funkciniai elementai taip pat gali būti naudojami norint paleisti giją C++. Šis kodo fragmentas parodo, kaip tai daroma:
Pavyzdys:
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)> |
>
>
Pastaba : Iškviečiamojo parametrus visada perduodame atskirai kaip argumentus gijos konstruktoriui.
Gijos paleidimas naudojant nestatinę nario funkciją
Taip pat galime paleisti giją naudodami nestatinę klasės nario funkciją. Toliau pateiktas fragmentas parodo, kaip tai padaryti.
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);> |
>
java nepakeičiamas sąrašas
>
Gijos paleidimas naudojant statinio nario funkciją
Taip pat galime paleisti gijas naudodami statines nario 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);> |
>
ilgio eilutė
>
Laukiama, kol baigsis siūlai
Pradėjus giją, gali tekti palaukti, kol gija baigsis, kad galėtume imtis kokių nors veiksmų. Pavyzdžiui, jei programos GUI inicijavimo užduotį priskiriame gijai, turime palaukti, kol gija baigsis, kad įsitikintume, jog GUI tinkamai įkelta.
Norėdami laukti gijos, naudokite std::thread::join() funkcija. Ši funkcija verčia dabartinę giją laukti, kol gijos identifikuojamos * tai baigė vykdyti.
Pavyzdžiui, norėdami užblokuoti pagrindinę giją, kol baigsis gija t1, darytume:
C++
git statusas
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Pilna C++ programa, skirta kelių gijų kūrimui
Toliau pateikiama C++ programa. Jis paleidžia tris gijas iš pagrindinės funkcijos. Kiekviena gija iškviečiama naudojant vieną iš pirmiau nurodytų iškviečiamų objektų.
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; }> |
>
>
Išvestis (priklausoma nuo mašinos)
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>
Pastaba: Norėdami kompiliuoti programas su std::thread palaikymu, naudokite g++ -std=c++11 -pthread.