Multithreading este o caracteristică care permite executarea concomitentă a două sau mai multe părți ale unui program pentru utilizarea maximă a procesorului. Fiecare parte a unui astfel de program se numește fir. Deci, firele sunt procese ușoare în cadrul unui proces.
piton de filtrare
Suportul multithreading a fost introdus în C++11. Înainte de C++11, trebuia să folosim Fire sau bibliotecă POSIX . În timp ce această bibliotecă a făcut treaba, lipsa oricărui set de caracteristici standard furnizate de limbaj a cauzat probleme serioase de portabilitate. C++ 11 a eliminat toate acestea și ne-a dat std::thread . Clasele de fire și funcțiile asociate sunt definite în fișier antet.
Sintaxă:
std::thread thread_object (callable);>
std::thread este clasa de fire care reprezintă un singur thread în C++. Pentru a începe un fir de execuție, trebuie pur și simplu să creăm un nou obiect de execuție și să trecem codul de execuție care urmează să fie apelat (adică un obiect apelabil) în constructorul obiectului. Odată ce obiectul este creat, se lansează un nou thread care va executa codul specificat în callable. Un apelabil poate fi oricare dintre cele cinci:
- Un indicator de funcție
- O expresie Lambda
- Un obiect funcție
- Funcția membru non-static
- Funcția membru static
După definirea apelabilului, îl transmitem constructorului.
Lansarea Threadului utilizând funcția Pointer
Un indicator de funcție poate fi un obiect apelabil pentru a fi transmis constructorului std::thread pentru inițializarea unui fir. Următorul fragment de cod demonstrează cum se face.
Exemplu:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Lansarea thread-ului folosind expresia Lambda
Obiectul std::thread poate fi, de asemenea, lansat folosind o expresie lambda ca apelabil. Următorul fragment de cod demonstrează cum se face acest lucru:
Exemplu:
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);> |
vizualizator java
>
>
Lansarea thread-ului folosind obiecte funcție
Obiectele sau Functorii pot fi, de asemenea, utilizați pentru lansarea unui fir în C++. Următorul fragment de cod demonstrează cum se face:
Exemplu:
C++
do while loop în java
// 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)> |
>
>
Notă : Întotdeauna trecem parametrii apelabilului separat ca argumente către constructorul firului.
Lansarea thread-ului folosind funcția membru non-static
De asemenea, putem lansa firul folosind funcția membru non-static a unei clase. Următorul fragment demonstrează cum se face.
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);> |
>
>
Lansarea firului utilizând funcția membru static
De asemenea, putem lansa firele folosind funcții membre statice.
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);> |
>
vlc descărca videoclipuri youtube
>
Se așteaptă ca firele să se termine
Odată ce a început un fir, ar putea fi nevoie să așteptăm ca firul să se termine înainte de a putea lua ceva. De exemplu, dacă alocam sarcina de inițializare a GUI a unei aplicații unui fir, trebuie să așteptăm ca firul să se termine pentru a ne asigura că GUI s-a încărcat corect.
Pentru a aștepta un thread, utilizați std::thread::join() funcţie. Această funcție face firul curent să aștepte până când firul identificat de *acest a terminat de executat.
De exemplu, pentru a bloca firul principal până când firul t1 s-a terminat, am face:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
șir la număr întreg
>
>
Un program complet C++ pentru multithreading
Un program C++ este prezentat mai jos. Lansează trei fire din funcția principală. Fiecare fir este apelat folosind unul dintre obiectele apelabile specificate mai sus.
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; }> |
>
>
Ieșire (în funcție de mașină)
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>
Notă: Pentru a compila programe cu suport std::thread utilizați g++ -std=c++11 -pthread.