Funzione 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
- policy
Un valore di avvio.
Note
Definizioni delle abbreviazioni:
dfn |
Il risultato della chiamata a decay_copy(forward<Fn>(fn)). |
dargs |
I risultati delle chiamate a decay_copy(forward<ArgsTypes>(args…)). |
Ty |
Tipo result_of<Fn(ArgTypes…)>::type. |
La prima funzione di modello restituisce async(launch::any, fn, args…).
La seconda funzione restituisce un oggetto future<Ty> in cui lo stato associato asincrono gestisce un risultato insieme ai valori dfn e dargs e un oggetto thread per gestire un thread separato di esecuzione.
A meno che decay<Fn>::type sia un tipo diverso dall'avvio, la seconda funzione non partecipa alla risoluzione dell'overload.
Se policy è launch::any, la funzione potrebbe scegliere launch::async o launch::deferred. In questa implementazione, la funzione utilizza launch::async.
Se policy è launch::async, la funzione crea un thread che restituisce INVOKE(dfn, dargs..., Ty). La funzione restituisce dopo avere creato il thread senza attendere i risultati. Se il sistema non può avviare un nuovo thread, la funzione lancia un system_error che contiene un codice di errore di resource_unavailable_try_again.
Se policy è launch::deferred, la funzione contrassegna il relativo stato asincrono come se fosse una funzione posticipata e restituisce. La prima chiamata a una funzione non temporizzata che aspetta che lo stato asincrono associato sia effettivamente pronto, chiama la funzione posticipata valutando INVOKE(dfn, dargs..., Ty).
In tutti i casi, lo stato asincrono associato all'oggetto future non viene impostato a pronto fino a quanto la valutazione di INVOKE(dfn, dargs…, Ty) non è stata completata, generando un'eccezione o restituendo normalmente. Il risultato dello stato asincrono associato è un'eccezione se ne è stata lanciata una, o un qualsiasi valore restituito dalla valutazione.
Nota
In future o nell'ultima shared_future che è collegata ad un task avviato tramite std::async, il distruttore va in blocco se il task non ha terminato; ovvero questo accade se il thread non ha ancora effettuato la chiamata a .get() o .wait() e il task è ancora in esecuzione.Se future ottenuto da std::async viene spostato fuori dell'ambito locale, l'altro codice che ne fa uso deve sapere che il relativo distruttore può andare in blocco fino a quando lo stato condiviso non è pronto.
La pseudo funzione INVOKE è definita in <functional>.
Requisiti
Intestazione: future
Spazio dei nomi: std