<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
policy
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 strettamente a questo comportamento. Ottiene i thread da Windows ThreadPool, che possono 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 vengano eliminate definitivamente al termine del thread. Se il thread viene riciclato e fornito a una nuova chiamata a async, le variabili precedenti esistono ancora. È consigliabile evitare di usare variabili locali del thread con async.
Se policy è launch::deferred, la funzione contrassegna il relativo stato asincrono associato come contenente una funzione posticipata e termina. La prima chiamata a qualsiasi funzione non timed che attende che lo stato asincrono associato sia pronto 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 o il 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>.
Specifico di Microsoft
Quando la funzione passata viene eseguita in modo asincrono, viene eseguita nel pool di thread di Windows. Per altre informazioni, vedere Pool di thread. Il numero di thread simultanei è limitato all'impostazione predefinita del pool di thread, ovvero 500 thread.
Prima di Windows 11 e Windows Server 2022, le applicazioni erano limitate per impostazione predefinita a un singolo gruppo di processori con al massimo 64 processori logici. In questo modo il numero di thread in esecuzione simultanea è limitato a 64. Per altre informazioni, vedere Gruppi di processori.
A partire da Windows 11 e Windows Server 2022, i processi e i relativi thread hanno affinità di processore che per impostazione predefinita si estendono a tutti i processori nel sistema e in più gruppi in computer con più di 64 processori. Il limite per il numero di thread simultanei è ora il numero totale di processori logici nel sistema.
future_category
Restituisce un riferimento all'oggetto error_category che caratterizza gli errori associati agli 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 future errori.
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.