El multithreading és una característica que permet l'execució simultània de dues o més parts d'un programa per a la màxima utilització de la CPU. Cada part d'aquest programa s'anomena fil. Per tant, els fils són processos lleugers dins d'un procés.
diferència entre dues cadenes python
El suport multithreading es va introduir a C++11. Abans de C++11, havíem d'utilitzar Fils o biblioteca POSIX . Tot i que aquesta biblioteca va fer la feina, la manca de cap conjunt de funcions proporcionades per un llenguatge estàndard va causar greus problemes de portabilitat. C++ 11 va eliminar tot això i ens va donar std::fil . Les classes de fils i les funcions relacionades es defineixen al fitxer fitxer de capçalera.
Sintaxi:
std::thread thread_object (callable);>
std::fil és la classe de fil que representa un sol fil en C++. Per iniciar un fil, només hem de crear un nou objecte de fil i passar el codi d'execució que cal cridar (és a dir, un objecte cridable) al constructor de l'objecte. Un cop creat l'objecte, s'inicia un nou fil que executarà el codi especificat a callable. Un callable pot ser qualsevol dels cinc:
- Un punter de funció
- Una expressió Lambda
- Un objecte de funció
- Funció de membre no estàtica
- Funció de membre estàtica
Després de definir l'anomenable, el passem al constructor.
Llançament del fil utilitzant el punter de funció
Un punter de funció pot ser un objecte cridable per passar al constructor std::thread per inicialitzar un fil. El fragment de codi següent mostra com es fa.
Exemple:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Llançament del fil mitjançant l'expressió Lambda
L'objecte std::thread també es pot llançar utilitzant una expressió lambda com a invocable. El fragment de codi següent mostra com es fa:
Exemple:
C++
imprimir matriu en java
// Define a lambda expression> auto> f = [](params)> {> >Statements;> };> // Pass f and its parameters to thread> // object constructor as> std::>thread> thread_object(f, params);> |
>
>
Llançament del fil utilitzant objectes de funció
Els objectes de funció o els funcionals també es poden utilitzar per llançar un fil en C++. El fragment de codi següent mostra com es fa:
Exemple:
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)> |
>
c++ int a cadena
>
Nota : Sempre passem els paràmetres de l'element cridable per separat com a arguments al constructor de fils.
Llançament del fil utilitzant la funció membre no estàtica
També podem llançar el fil utilitzant la funció membre no estàtica d'una classe. El fragment següent mostra com fer-ho.
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);> |
>
>
Llançament del fil utilitzant la funció de membre estàtica
També podem llançar els fils utilitzant funcions de membre estàtiques.
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);> |
>
algorisme de kruskals
>
Esperant que s'acabin els fils
Un cop s'ha iniciat un fil, és possible que hàgim d'esperar que s'acabi abans de poder prendre alguna acció. Per exemple, si assignem la tasca d'inicialitzar la GUI d'una aplicació a un fil, haurem d'esperar que acabi el fil per assegurar-nos que la GUI s'ha carregat correctament.
Per esperar un fil, utilitzeu std::thread::join() funció. Aquesta funció fa que el fil actual espere fins al fil identificat per *això s'ha acabat d'executar.
Per exemple, per bloquejar el fil principal fins que s'hagi acabat el fil t1, faríem:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Un programa C++ complet per a multiprocés
A continuació es mostra un programa en C++. Llança tres fils des de la funció principal. Cada fil s'anomena utilitzant un dels objectes invocables especificats anteriorment.
C++
bucle bash while
// 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; }> |
>
>
Sortida (depenent de la màquina)
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>
Nota: Per compilar programes amb suport std::thread, utilitzeu g++ -std=c++11 -pthread.