<future> – funkce

async
future_category
make_error_code
make_error_condition
swap|

async

Představuje asynchronního zprostředkovatele.

template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
    async(Fn&& fn, ArgTypes&&... args);

template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
    async(launch policy, Fn&& fn, ArgTypes&&... args);

Parametry

Zásad
Hodnota launch .

Poznámky

Definice zkratek:

Zkratka	Popis
dfn	Výsledek volání funkce decay_copy(forward<Fn>(fn)).
dargs	Výsledky volání funkce decay_copy(forward<ArgsTypes>(args...)).
Ty	Typ result_of<Fn(ArgTypes...)>::type.

První šablona funkce vrátí funkci async(launch::any, fn, args...).

Druhá funkce vrátí objekt, future<Ty> jehož přidružený asynchronní stav obsahuje výsledek společně s hodnotami dfn a dargs objekt vlákna pro správu samostatného vlákna provádění.

Pokud decay<Fn>::type není jiný typ než spuštění, druhá funkce se nepředstaví v rozlišení přetížení.

Standard C++ uvádí, že pokud je zásada launch::async, funkce vytvoří nové vlákno. Implementace Microsoftu ale v současné době nevyhovuje. Získá svá vlákna z fondu vláken Systému Windows, který v některých případech může poskytnout recyklované vlákno, nikoli nové vlákno. To znamená, že launch::async zásada se implementuje jako launch::async|launch::deferred. Další implikací implementace založené na threadPoolu je, že neexistuje žádná záruka, že po dokončení vlákna dojde ke zničení místních proměnných vlákna. Pokud je vlákno recyklováno a poskytováno novému volání async, staré proměnné budou stále existovat. Doporučujeme, abyste nepoužívejte místní proměnné vlákna s async.

Pokud je launch::deferredzásada , funkce označí přidružený asynchronní stav jako držení odložené funkce a vrátí. První volání jakékoli nečasové funkce, která čeká, až bude související asynchronní stav připraven, v důsledku volá odloženou funkci pomocí vyhodnocení funkce INVOKE(dfn, dargs..., Ty).

Ve všech případech není přidružený asynchronní stav objektu future nastavený tak, aby byl připravený až do vyhodnocení INVOKE(dfn, dargs..., Ty) dokončení, buď vyvoláním výjimky nebo normálním vrácením. Výsledek přidruženého asynchronního stavu je výjimka, pokud byla nějaká vyvolána, nebo libovolná hodnota, která je vrácena vyhodnocením.

Poznámka

futureU úkolu ( nebo posledníhoshared_future) připojeného k úkolu, který byl spuštěn std::async, bloky destruktoru, pokud úkol nebyl dokončen; to znamená, že blokuje, pokud toto vlákno ještě nevolá .get() nebo .wait() úkol je stále spuštěný. Pokud je objekt future získaný z volání funkce std::async přesunut mimo místní rozsah, jiný kód, který jej používá, musí vědět, že jeho destruktor může být blokován, než sdílený stav změní na stav připraven.

Pseudofunkce INVOKE je definována v <functional>.

Specifické pro Microsoft

Když se předaná funkce spustí asynchronně, spustí se ve fondu vláken Systému Windows; viz Fondy vláken. Počet souběžných vláken je omezen na výchozí fond vláken (aktuálně 500). Počet vláken souběžně spuštěných na hardwaru je v současné době omezen počtem logických procesorů ve skupině procesorů procesu, takže je efektivně omezen na 64; viz Skupiny procesorů.

future_category

Vrátí odkaz na objekt error_category , který charakterizuje chyby spojené s future objekty.

const error_category& future_category() noexcept;

make_error_code

Vytvoří error_code společně s objektem error_category, který charakterizuje budoucí chyby.

inline error_code make_error_code(future_errc Errno) noexcept;

Parametry

Errno
Hodnota future_errc , která identifikuje hlášenou chybu.

Vrácená hodnota

error_code(static_cast<int>(Errno), future_category());

make_error_condition

Vytvoří error_condition společně s objektem error_category, který charakterizuje budoucí chyby.

inline error_condition make_error_condition(future_errc Errno) noexcept;

Parametry

Errno
Hodnota future_errc , která identifikuje hlášenou chybu.

Vrácená hodnota

error_condition(static_cast<int>(Errno), future_category());

swap

Vymění přidružený asynchronní stav jednoho promise objektu s jiným objektem.

template <class Ty>
void swap(promise<Ty>& Left, promise<Ty>& Right) noexcept;

template <class Ty, class... ArgTypes>
void swap(packaged_task<Ty(ArgTypes...)>& Left, packaged_task<Ty(ArgTypes...)>& Right) noexcept;

Parametry

Left
Levý promise objekt.

Right
Správný promise objekt.

Viz také

<future>