Partager via


async, fonction

Représente un fournisseur asynchrone.

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

Paramètres

Notes

Définitions des abréviations :

dfn

Le résultat de l'appel decay_copy(forward<Fn>(fn)).

dargs

Résultats de l'appel decay_copy(forward<ArgsTypes>(args…)).

Ty

Le type result_of<Fn(ArgTypes…)>::type.

La première fonction de modèle retourne async(launch::any, fn, args…).

La deuxième fonction retourne un future<Ty> objet dont l'état asynchrone associé gère un résultat avec les valeurs d'dfn et d'dargs et un objet thread pour gérer un thread séparé d'exécution.

À moins que decay<Fn>::type ne soit un type autre que lancement, la deuxième fonction ne participe pas à la résolution de surcharge.

Si policy est launch::any, la fonction pourrait choisir launch::async ou launch::deferred. Dans cette implémentation, la fonction utilise launch::async.

Si policy est launch::async, la fonction crée un thread qui évalue INVOKE(dfn, dargs..., Ty). La fonction revient où elle en était après qu'elle a créé le thread sans attendre de résultats. Si le système ne peut pas démarrer un nouveau thread, la fonction lève system_error qui a un code d'erreur d'resource_unavailable_try_again.

Si policy est launch::deferred, la fonction marque son état asynchrone associé comme possédant une fonction différée et revient là où elle en était restée. Le premier appel à toute fonction non temporisée qui attend l'état asynchrone associé pour être accessible appelle la fonction différée en évaluant INVOKE(dfn, dargs..., Ty).

Dans tous les cas, l'état asynchrone associé à l'objet future n'est pas défini être prêt jusqu'à ce que l'évaluation d'INVOKE(dfn, dargs…, Ty) soit terminée, en levant une exception ou en retournant normalement à l'exécution. Le résultat de l'état asynchrone associé est une exception si une a été levée, ou toute valeur retournée par l'évaluation.

Notes

Pour future(ou dernier shared_future— qui est attaché à une tâche démarrée avec std::async, les blocs de destructeur si la tâche ne s'est pas terminée ; autrement dit, il bloque si ce thread n'a pas encore .get() ou .wait() et la tâche s'exécute toujours.Si future obtenu à partir de std::async est déplacé à l'extérieur de la portée locale, un code qui l'utilise doit savoir que son destructeur ne se bloquer pour l'état partagé soit prête.

La pseudo-code fonction INVOKE est définie dans <functional>.

Configuration requise

En-tête : future

Espace de noms : std

Voir aussi

Référence

<future>

result_of, classe

future, classe

Autres ressources

Fichiers d'en-tête de bibliothèque standard C++