Večnitnost je funkcija, ki omogoča hkratno izvajanje dveh ali več delov programa za največjo izkoriščenost procesorja. Vsak del takega programa se imenuje nit. Torej so niti lahki procesi znotraj procesa.
java binarno drevo
Podpora za večnitnost je bila predstavljena v C++11. Pred C++11 smo morali uporabljati Niti ali knjižnica POSIX . Medtem ko je ta knjižnica opravila svoje delo, je pomanjkanje nabora standardnih jezikovnih funkcij povzročilo resne težave s prenosljivostjo. C++ 11 je vse to odpravil in nam dal std::nit . Razredi niti in sorodne funkcije so definirani v naslovna datoteka.
Sintaksa:
std::thread thread_object (callable);>
std::nit je razred niti, ki predstavlja eno samo nit v C++. Za zagon niti moramo preprosto ustvariti nov predmet niti in posredovati izvajalno kodo, ki jo je treba poklicati (tj. predmet, ki ga je mogoče priklicati), v konstruktor predmeta. Ko je objekt ustvarjen, se zažene nova nit, ki bo izvedla kodo, podano v callable. Klicatelj je lahko kateri koli od petih:
- Kazalec funkcije
- Lambda izraz
- Funkcijski objekt
- Nestatična funkcija člana
- Statična funkcija člana
Ko definiramo klicač, ga posredujemo konstruktorju.
Zagon niti s kazalcem funkcije
Funkcijski kazalec je lahko predmet, ki ga je mogoče priklicati, da se posreduje konstruktorju std::thread za inicializacijo niti. Naslednji delček kode prikazuje, kako se to naredi.
primer:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Zagon niti z uporabo lambda izraza
Objekt std::thread je mogoče zagnati tudi z uporabo izraza lambda kot klicatelja. Naslednji delček kode prikazuje, kako se to naredi:
primer:
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);> |
>
js večvrstični niz
>
Zagon niti z uporabo funkcijskih objektov
Funkcijske objekte ali funktorje je mogoče uporabiti tudi za zagon niti v C++. Naslednji delček kode prikazuje, kako se to naredi:
primer:
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)> |
java je enaka
>
>
Opomba : Parametre klicatelja vedno posredujemo ločeno kot argumente konstruktorju niti.
Zagon niti z uporabo nestatične funkcije člana
Nit lahko zaženemo tudi z uporabo nestatične funkcije člana razreda. Naslednji delček prikazuje, kako to storiti.
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);> |
>
>
Zagon niti z uporabo statične funkcije člana
Niti lahko zaženemo tudi z uporabo statičnih članskih funkcij.
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);> |
>
kako najti velikost monitorja
>
Čakam, da se niti končajo
Ko se nit začne, bomo morda morali počakati, da se nit konča, preden lahko ukrepamo. Na primer, če nalogo inicializacije GUI aplikacije dodelimo niti, moramo počakati, da se nit konča, da zagotovimo, da se je GUI pravilno naložil.
Če želite počakati na nit, uporabite std::thread::join() funkcijo. Ta funkcija poskrbi, da trenutna nit počaka, dokler nit, ki jo identificira *to je končal z izvajanjem.
Na primer, če želimo blokirati glavno nit, dokler nit t1 ni končana, bi naredili:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
algoritmi binarnega iskanja
>
>
Popoln program C++ za večnitnost
Spodaj je podan program C++. Zažene tri niti iz glavne funkcije. Vsaka nit je poklicana z enim od zgoraj navedenih predmetov, ki jih je mogoče priklicati.
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; }> |
>
>
Izhod (odvisno od stroja)
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>
Opomba: Za prevajanje programov s podporo za std::thread uporabite g++ -std=c++11 -pthread.