Multithreading je funkce, která umožňuje souběžné provádění dvou nebo více částí programu pro maximální využití CPU. Každá část takového programu se nazývá vlákno. Vlákna jsou tedy lehké procesy v rámci procesu.
numpy log
Podpora multithreadingu byla zavedena v C++11. Před C++ 11 jsme museli používat POSIX vlákna nebo knihovna . I když tato knihovna odvedla svou práci, nedostatek jakékoli standardní sady funkcí poskytovaných v jazyce způsobil vážné problémy s přenositelností. C++ 11 to všechno odstranil a dal nám std::vlákno . Třídy vláken a související funkce jsou definovány v hlavičkový soubor.
Syntax:
std::thread thread_object (callable);>
std::vlákno je třída vláken, která představuje jedno vlákno v C++. Ke spuštění vlákna stačí vytvořit nový objekt vlákna a předat spouštěcí kód, který má být volán (tj. volatelný objekt), do konstruktoru objektu. Jakmile je objekt vytvořen, spustí se nové vlákno, které spustí kód zadaný v callable. Volatelný může být kterýkoli z pěti:
- Ukazatel funkce
- Lambda výraz
- Objekt funkce
- Nestatická členská funkce
- Statická členská funkce
Po definování callable jej předáme konstruktoru.
Spuštění vlákna pomocí ukazatele funkce
Ukazatel funkce může být volatelný objekt, který se předá konstruktoru std::thread pro inicializaci vlákna. Následující fragment kódu ukazuje, jak se to dělá.
Příklad:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Spuštění vlákna pomocí Lambda Expression
Objekt std::thread lze také spustit pomocí výrazu lambda jako callable. Následující fragment kódu ukazuje, jak se to dělá:
Příklad:
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);> |
>
>
Spuštění vlákna pomocí funkčních objektů
Objekty funkcí nebo funktory lze také použít pro spouštění vlákna v C++. Následující fragment kódu ukazuje, jak se to dělá:
Příklad:
C++
bajtů na řetězec python
// 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 : Parametry callable vždy předáváme samostatně jako argumenty konstruktoru vláken.
Spuštění vlákna pomocí nestatické členské funkce
Vlákno můžeme také spustit pomocí nestatické členské funkce třídy. Následující úryvek ukazuje, jak na to.
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);> |
>
hranatý materiál
>
Spuštění vlákna pomocí funkce statického člena
Vlákna můžeme také spouštět pomocí statických členských funkcí.
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 jazyce c
>
Čekání na dokončení vláken
Jakmile vlákno začalo, možná budeme muset počkat, až vlákno skončí, než budeme moci provést nějakou akci. Pokud například přidělíme úlohu inicializace GUI aplikace vláknu, musíme počkat, až vlákno skončí, abychom se ujistili, že se GUI správně načetlo.
Chcete-li počkat na vlákno, použijte std::thread::join() funkce. Tato funkce způsobí, že aktuální vlákno čeká, dokud vlákno identifikované pomocí *tento dokončilo provádění.
Chcete-li například zablokovat hlavní vlákno, dokud nedokončí vlákno t1, udělali bychom:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Kompletní C++ program pro multithreading
Níže je uveden program C++. Z hlavní funkce spustí tři vlákna. Každé vlákno je voláno pomocí jednoho z volatelných objektů uvedených výše.
C++
datum převodu řetězce
// 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ý na stroji)
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: Ke kompilaci programů s podporou std::thread použijte g++ -std=c++11 -pthread.