Multithreading je funkcia, ktorá umožňuje súčasné vykonávanie dvoch alebo viacerých častí programu pre maximálne využitie CPU. Každá časť takéhoto programu sa nazýva vlákno. Takže vlákna sú ľahké procesy v rámci procesu.
odstrániť súbor v java
Podpora multithreadingu bola zavedená v C++11. Pred C++ 11 sme museli použiť POSIX vlákna alebo knižnica . Zatiaľ čo táto knižnica vykonávala túto prácu, nedostatok akejkoľvek štandardnej sady funkcií poskytovaných v jazyku spôsobil vážne problémy s prenosnosťou. C++ 11 to všetko odstránil a dal nám std::vlákno . Triedy vlákien a súvisiace funkcie sú definované v hlavičkový súbor.
Syntax:
std::thread thread_object (callable);>
std::vlákno je trieda vlákien, ktorá predstavuje jedno vlákno v C++. Ak chcete spustiť vlákno, jednoducho musíme vytvoriť nový objekt vlákna a odovzdať vykonávací kód, ktorý sa má volať (t. j. volateľný objekt), do konštruktora objektu. Po vytvorení objektu sa spustí nové vlákno, ktoré spustí kód špecifikovaný v callable. Volateľný môže byť ktorýkoľvek z piatich:
- Ukazovateľ funkcie
- Lambda výraz
- Objekt funkcie
- Nestatická členská funkcia
- Funkcia statického člena
Po zadefinovaní callable ho odovzdáme konštruktorovi.
Spustenie vlákna pomocou ukazovateľa funkcie
Ukazovateľ funkcie môže byť volateľný objekt, ktorý sa má odovzdať konštruktorovi std::thread na inicializáciu vlákna. Nasledujúci úryvok kódu ukazuje, ako sa to robí.
Príklad:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Spustenie vlákna pomocou výrazu Lambda
Objekt std::thread možno spustiť aj pomocou výrazu lambda ako volateľný. Nasledujúci útržok kódu ukazuje, ako sa to robí:
Príklad:
C++
pothineni baran
// Define a lambda expression> auto> f = [](params)> {> >Statements;> };> // Pass f and its parameters to thread> // object constructor as> std::>thread> thread_object(f, params);> |
>
>
Spustenie vlákna pomocou funkčných objektov
Na spustenie vlákna v C++ možno použiť aj funkčné objekty alebo funktory. Nasledujúci útržok kódu ukazuje, ako sa to robí:
Príklad:
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)> |
>
>
Poznámka : Parametre volanej položky vždy odovzdávame samostatne ako argumenty konštruktorovi vlákna.
Spustenie vlákna pomocou funkcie nestatického člena
Vlákno môžeme spustiť aj pomocou nestatickej členskej funkcie triedy. Nasledujúci úryvok ukazuje, ako na to.
C++
hlavné java
// 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);> |
>
>
Spustenie vlákna pomocou funkcie statického člena
Vlákna môžeme spustiť aj pomocou statických členských funkcií.
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);> |
>
matice v jazyku c
>
Čaká sa na dokončenie vlákien
Po spustení vlákna možno budeme musieť počkať, kým sa vlákno skončí, aby sme mohli vykonať nejakú akciu. Napríklad, ak pridelíme úlohu inicializácie GUI aplikácie vláknu, musíme počkať na dokončenie vlákna, aby sme sa uistili, že sa GUI správne načítalo.
Ak chcete počkať na vlákno, použite std::thread::join() funkciu. Táto funkcia spôsobí, že aktuálne vlákno čaká, kým vlákno identifikované pomocou *toto dokončilo vykonávanie.
Ak chcete napríklad zablokovať hlavné vlákno, kým sa neskončí vlákno t1, urobili by sme:
C++
q3 mesiace
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Kompletný program C++ pre viacvláknové spracovanie
Program C++ je uvedený nižšie. Z hlavnej funkcie spustí tri vlákna. Každé vlákno sa volá pomocou jedného z volateľných objektov špecifikovaných vyššie.
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; }> |
>
>
Výstup (závislý 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>
Poznámka: Na kompiláciu programov s podporou std::thread použite g++ -std=c++11 -pthread.