Monisäikeistys on ominaisuus, joka mahdollistaa ohjelman kahden tai useamman osan samanaikaisen suorittamisen prosessorin maksimaalisen käytön varmistamiseksi. Jokaista tällaisen ohjelman osaa kutsutaan säikeeksi. Joten langat ovat kevyitä prosesseja prosessin sisällä.
sed-komento
Monisäikeinen tuki otettiin käyttöön C++11:ssä. Ennen C++11:tä meidän piti käyttää POSIX-säikeet tai kirjasto . Vaikka tämä kirjasto teki tehtävänsä, vakiokielisten ominaisuuksien puuttuminen aiheutti vakavia siirrettävyysongelmia. C++ 11 poisti kaiken tämän ja antoi meille std::ketju . Säikeen luokat ja niihin liittyvät funktiot on määritelty otsikkotiedosto.
Syntaksi:
std::thread thread_object (callable);>
std::ketju on säieluokka, joka edustaa yhtä säiettä C++:ssa. Säikeen aloittamiseksi meidän on yksinkertaisesti luotava uusi säieobjekti ja välitettävä kutsuttava suorituskoodi (eli kutsuttava objekti) objektin rakentajalle. Kun objekti on luotu, käynnistetään uusi säie, joka suorittaa kutsuttavana määritetyn koodin. Kutsuttava voi olla mikä tahansa viidestä:
- Toimintoosoitin
- Lambda-ilmaisu
- Toimintoobjekti
- Ei-staattinen jäsentoiminto
- Staattinen jäsentoiminto
Kun kutsuttava on määritelty, välitämme sen rakentajalle.
Langan käynnistäminen Function Pointerin avulla
Funktioosoitin voi olla kutsuttava objekti, joka siirretään std::thread-konstruktorille säikeen alustamista varten. Seuraava koodinpätkä osoittaa, kuinka se tehdään.
Esimerkki:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Lankan käynnistäminen Lambda Expressionin avulla
std::thread-objekti voidaan käynnistää myös käyttämällä lambda-lauseketta kutsuttavana. Seuraava koodinpätkä osoittaa, kuinka tämä tehdään:
Esimerkki:
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);> |
>
>
Langan käynnistäminen funktioobjektien avulla
Funktioobjekteja tai funktioita voidaan käyttää myös säikeen käynnistämiseen C++:ssa. Seuraava koodinpätkä osoittaa, miten se tehdään:
Esimerkki:
C++
kuinka monta 0 miljardista
// 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)> |
>
>
Huomautus : Välitämme kutsuttavan parametrit aina erikseen argumentteina säikeen rakentajalle.
Lankan käynnistäminen ei-staattisen jäsenfunktion avulla
Voimme myös käynnistää säikeen käyttämällä luokan ei-staattista jäsenfunktiota. Seuraava katkelma osoittaa, kuinka se tehdään.
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);> |
verkko ja internet
>
>
Langan käynnistäminen staattisen jäsenfunktion avulla
Voimme myös käynnistää säikeet käyttämällä staattisia jäsentoimintoja.
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);> |
>
java paluu komento
>
Odotetaan lankojen loppumista
Kun viestiketju on alkanut, meidän on ehkä odotettava ketjun päättymistä ennen kuin voimme ryhtyä toimiin. Jos esimerkiksi annamme sovelluksen graafisen käyttöliittymän alustamisen tehtäväksi säikeelle, meidän on odotettava säikeen päättymistä varmistaaksemme, että graafinen käyttöliittymä on latautunut oikein.
Jos haluat odottaa lankaa, käytä std::thread::join() toiminto. Tämä toiminto saa nykyisen säikeen odottamaan, kunnes viestiketju on tunnistettu *Tämä on suorittanut loppuun.
Esimerkiksi, jos haluat estää pääsäikeen, kunnes säie t1 on päättynyt, toimisimme seuraavasti:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Täydellinen C++-ohjelma monisäikeistykseen
Alla on C++-ohjelma. Se käynnistää kolme säiettä päätoiminnosta. Jokaista säiettä kutsutaan käyttämällä yhtä yllä määritetyistä kutsuvista objekteista.
C++
ohut algoritmi
// 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; }> |
>
>
Lähtö (koneriippuvainen)
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>
Huomautus: Kääntääksesi ohjelmia std::thread-tuella käytä g++ -std=c++11 -pthreadia.