Knihovna podpory vláken
C++ zahrnuje vestavěnou podporu pro vlákna, vzájemné vyloučení, podmíněné proměnné a futury.
Obsah |
[editovat] Vlákna
Vlákne umožňují programům souběžný běh na více procesorových jader.
| Definováno v hlavičkovém souboru
<thread> | |
| (C++11) |
manages a separate thread (class) |
Funkce pro správu aktivního vlákna | |
| Definováno v jmenném prostoru
this_thread | |
| (C++11) |
suggests that the implementation reschedule execution of threads (function) |
| (C++11) |
vrací vláknové id současného vlákna (function) |
| (C++11) |
na zadanou dobu pozastaví provádění současného vlákna (function) |
| (C++11) |
pozastaví provádění současného vlákna až do zadaného okamžiku (function) |
[editovat] Vzájemné vyloučení
Algoritmy vzájemného vyloučení (anglicky mutual exclusion algorithms) zabraňují současnému přístupu vícero vláken ke stejným sdíleným zdrojům. Tím zabraňují vzniku datového souběhu a nabízí podporu pro synchronizaci vláken.
Šablona:cpp/thread/dsc shared timed mutex| Definováno v hlavičkovém souboru
<mutex> | |
| (C++11) |
provides basic mutual exclusion facility (class) |
| (C++11) |
provides mutual exclusion facility which implements locking with a timeout (class) |
| (C++11) |
provides mutual exclusion facility which can be locked recursively by the same thread (class) |
| (C++11) |
provides mutual exclusion facility which can be locked recursively by the same thread and implements locking with a timeout (class) |
| Definováno v hlavičkovém souboru
<shared_mutex> | |
Generic mutex management | |
| Definováno v hlavičkovém souboru
<mutex> | |
| (C++11) |
implements a strictly scope-based mutex ownership wrapper (class template) |
| (C++11) |
implements movable mutex ownership wrapper (class template) |
| (C++14) |
implements movable shared mutex ownership wrapper (class template) |
| (C++11)(C++11)(C++11) |
tag type used to specify locking strategy (class) |
| (C++11)(C++11)(C++11) |
tag constants used to specify locking strategy (constant) |
Generic locking algorithms | |
| (C++11) |
attempts to obtain ownership of mutexes via repeated calls to try_lock (šablona funkce) |
| (C++11) |
locks specified mutexes, blocks if any are unavailable (šablona funkce) |
Call once | |
| (C++11) |
helper object to ensure that call_once invokes the function only once (class) |
| (C++11) |
invokes a function only once even if called from multiple threads (šablona funkce) |
[editovat] Podmíněné proměnné
Podmíněná proměnná patří mezi synchronizační primitiva, která umožňují komunikace mezi různými vlákny. Umožňuje vláknům čekat (případně s lhůtou) na upozornění od jiného vlákna, že mohou pokračovat. Podmíněná proměnná je vždy spojená s konkrétním vzájemným vyloučením (mutexem).
| Definováno v hlavičkovém souboru
<condition_variable> | |
| (C++11) |
provides a condition variable associated with a std::unique_lock (class) |
| (C++11) |
provides a condition variable associated with any lock type (class) |
| (C++11) |
schedules a call to notify_all to be invoked when this thread is completely finished (function) |
| (C++11) |
lists the possible results of timed waits on condition variables (enum) |
[editovat] Futury
Standardní knihovna poskytuje nástroje, jak získat návratové hodnoty a chytat výjimky asynchronních úloh (tedy funkcí prováděných v oddělených vláknech). Tyto hodnoty jsou předávány v sdíleném stavu, do kterého může asynchronní úloha zapsat svou návratovou hodnotu nebo uložit výjimku, a který mohou zkoumat, na který mohou čekat a s kterým mohou i jinak pracovat jiná vlákna, která mají instanci std::future nebo std::shared_future, která k sdílenému stavu odkazuje.
| Definováno v hlavičkovém souboru
<future> | |
| (C++11) |
stores a value for asynchronous retrieval (class template) |
| (C++11) |
packages a function to store its return value for asynchronous retrieval (class template) |
| (C++11) |
waits for a value that is set asynchronously (class template) |
| (C++11) |
waits for a value (possibly referenced by other futures) that is set asynchronously (class template) |
| (C++11) |
runs a function asynchronously (potentially in a new thread) and returns a std::future that will hold the result (šablona funkce) |
| (C++11) |
specifies the launch policy for std::async (enum) |
| (C++11) |
specifies the results of timed waits performed on std::future and std::shared_future (enum) |
Future errors | |
| (C++11) |
reports an error related to futures or promises (class) |
| (C++11) |
identifies the future error category (function) |
| (C++11) |
identifies the future error codes (enum) |
[editovat] Vizte též
| C documentation for Knihovna podpory vláken
|
