<future> funzioni

async
future_category
make_error_code
make_error_condition
swap|

async

Rappresenta un provider asincrono.

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);

Parametri

politica
Valore launch.

Osservazioni:

Definizioni delle abbreviazioni:

Abbreviazione	Descrizione
dfn	Risultato della chiamata a decay_copy(forward<Fn>(fn)).
dargs	Risultati delle chiamate decay_copy(forward<ArgsTypes>(args...)).
Ty	Tipo result_of<Fn(ArgTypes...)>::type.

La prima funzione modello restituisce async(launch::any, fn, args...).

La seconda funzione restituisce un future<Ty> oggetto il cui stato asincrono associato contiene un risultato insieme ai valori di dfn e dargs e a un oggetto thread per gestire un thread di esecuzione separato.

A meno che decay<Fn>::type non sia un tipo diverso dall'avvio, la seconda funzione non partecipa alla risoluzione dell'overload.

Lo standard C++ indica che se il criterio è launch::async, la funzione si comporta come se richiamasse l'oggetto chiamabile in un nuovo thread. Ciò significa che, mentre in genere comporta la creazione di un nuovo thread, l'implementazione può usare altri meccanismi per ottenere un comportamento equivalente. Tuttavia, l'implementazione di Microsoft attualmente non è conforme rigorosamente a questo comportamento. Ottiene i thread da Windows ThreadPool, che può fornire un thread riciclato anziché un nuovo thread. Ciò significa che i launch::async criteri vengono implementati in modo efficace come launch::async|launch::deferred. Un'altra implicazione dell'implementazione basata su ThreadPool è che non esiste alcuna garanzia che le variabili locali del thread verranno distrutte al termine del thread. Se il thread viene riciclato e fornito a una nuova chiamata a async, le variabili precedenti continueranno a esistere. È consigliabile evitare di usare variabili locali del thread con async.

Se il criterio è launch::deferred, la funzione contrassegna lo stato asincrono associato come contenente una funzione posticipata e restituisce. La prima chiamata a qualsiasi funzione non temporizzata che attende che lo stato asincrono associato sia ready in effetti chiama la funzione posticipata valutando INVOKE(dfn, dargs..., Ty).

In tutti i casi, lo stato asincrono associato dell'oggetto future non è impostato su pronto fino al completamento della INVOKE(dfn, dargs..., Ty) valutazione, generando un'eccezione o restituendo normalmente. Il risultato dello stato asincrono associato è un'eccezione se ne è stata generata una oppure qualsiasi valore restituito dalla valutazione.

Nota

Per un oggetto future, o l'ultimo shared_future, collegato a un'attività avviata con std::async, il distruttore blocca se l'attività non è stata completata, ovvero blocca se il thread non ha ancora chiamato .get() o .wait() e l'attività è ancora in esecuzione. Se un oggetto future ottenuto da std::async viene spostato al di fuori dell'ambito locale, l'altro codice che lo usa deve tenere presente che il relativo distruttore può bloccarsi per consentire allo stato condiviso di diventare ready.

La pseudo-funzione INVOKE è definita in <functional>.

Sezione specifica Microsoft

Quando la funzione passata viene eseguita in modo asincrono, viene eseguita nel pool di thread di Windows; vedere Pool di thread. Il numero di thread simultanei è limitato all'impostazione predefinita del pool di thread (attualmente 500). Il numero di thread eseguiti simultaneamente sull'hardware è attualmente limitato dal numero di processori logici nel gruppo di processori del processo, quindi è effettivamente limitato a 64; vedere Gruppi di processori.

future_category

Restituisce un riferimento all'oggetto error_category che caratterizza gli errori associati a oggetti future.

const error_category& future_category() noexcept;

make_error_code

Crea un oggetto error_code insieme all'oggetto error_category che caratterizza gli errori future.

inline error_code make_error_code(future_errc Errno) noexcept;

Parametri

Errno
Valore future_errc che identifica l'errore segnalato.

Valore restituito

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

make_error_condition

Crea un oggetto error_condition insieme all'oggetto error_category che caratterizza gli errori future.

inline error_condition make_error_condition(future_errc Errno) noexcept;

Parametri

Errno
Valore future_errc che identifica l'errore segnalato.

Valore restituito

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

swap

Scambia lo stato asincrono associato di un oggetto promise con quello di un altro oggetto.

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;

Parametri

Left
L'oggetto promise a sinistra.

Right
L'oggetto promise corretto.

Vedi anche

<future>