task (Concurrency Runtime), classe
Classe task
de la bibliothèque de modèles parallèles (PPL, Parallel Patterns Library). Un task
objet représente le travail qui peut être exécuté de manière asynchrone et simultanée avec d’autres tâches et travaux parallèles générés par des algorithmes parallèles dans le runtime d’accès concurrentiel. Il génère un résultat de type _ResultType
quand il s'exécute correctement. Les tâches de type task<void>
ne génèrent aucun résultat. Une tâche peut être mise en attente et annulée indépendamment des autres tâches. Il peut également être composé avec d’autres tâches à l’aide de continuations( then
), et de jointure( when_all
) et de modèles de choix( when_any
). Lorsqu’un objet de tâche est affecté à une nouvelle variable, le comportement est celui de std::shared_ptr
; en d’autres termes, les deux objets représentent la même tâche sous-jacente.
template <>
class task<void>;
template<typename _ResultType>
class task;
_ResultType
Type du résultat produit par la tâche.
Nom | Description |
---|---|
result_type |
Type de résultat produit par un objet de cette classe. |
Nom | Description |
---|---|
tâche | Surcharge. Construit un objet task . |
Nom | Description |
---|---|
get | Surcharge. Retourne le résultat produit par cette tâche. Si la tâche n’est pas dans un état terminal, un appel à get attendra que la tâche se termine. Cette méthode ne retourne pas de valeur lorsqu’elle est appelée sur une tâche dont le result_type a la valeur void . |
is_apartment_aware | Détermine si la tâche désencapsule une interface IAsyncInfo Windows Runtime ou descend de cette tâche. |
is_done | Détermine si la tâche est terminée. |
programmateur | Retourne le planificateur pour cette tâche. |
then | Surcharge. Ajoute une tâche de continuation à cette tâche. |
wait | Attend que cette tâche atteigne un état terminal. Il est possible que wait exécute la tâche inline si toutes les dépendances de tâches sont remplies et si elle n’a pas déjà été sélectionnée pour être exécutée par un processus de travail d’arrière-plan. |
Nom | Description |
---|---|
operator!= | Surcharge. Détermine si deux objets task représentent différentes tâches internes. |
operator= | Surcharge. Remplace le contenu d'un objet task par un autre. |
operator== | Surcharge. Détermine si deux objets task représentent la même tâche interne. |
Pour plus d’informations, consultez Parallélisme des tâches.
task
En-tête : ppltasks.h
Espace de noms : concurrency
Retourne le résultat produit par cette tâche. Si la tâche n’est pas dans un état terminal, un appel à get
attendra que la tâche se termine. Cette méthode ne retourne pas de valeur lorsqu’elle est appelée sur une tâche dont le result_type
a la valeur void
.
_ResultType get() const;
void get() const;
Résultat de la tâche.
Si la tâche est annulée, un appel à get
levera une exception task_canceled . Si la tâche rencontre une exception différente ou si une exception est propagée à cette tâche à partir d'une tâche précédente, un appel à get
lève cette exception.
Important
Dans une application plateforme Windows universelle (UWP), n’appelez pas concurrency ::task ::wait ou get
( wait
appelsget
) dans le code qui s’exécute sur le thread d’interface utilisateur. Dans le cas contraire, le runtime lève la concurrence ::invalid_operation , car ces méthodes bloquent le thread actuel et peuvent empêcher la réponse de l’application. Toutefois, vous pouvez appeler la get
méthode pour recevoir le résultat de la tâche antécédente dans une continuation basée sur des tâches, car le résultat est immédiatement disponible.
Détermine si la tâche désencapsule une interface IAsyncInfo
Windows Runtime ou descend de cette tâche.
bool is_apartment_aware() const;
true
si la tâche supprime une IAsyncInfo
interface ou est décroissante d’une telle tâche, false
sinon.
Détermine si la tâche est terminée.
bool is_done() const;
True si la tâche est terminée, false dans le cas contraire.
La fonction retourne true si la tâche est terminée ou annulée (avec ou sans exception utilisateur).
Détermine si deux objets task
représentent différentes tâches internes.
bool operator!= (const task<_ResultType>& _Rhs) const;
bool operator!= (const task<void>& _Rhs) const;
_Rhs
Tâche à comparer.
true
si les objets font référence à différentes tâches sous-jacentes et false
sinon.
Remplace le contenu d'un objet task
par un autre.
task& operator= (const task& _Other);
task& operator= (task&& _Other);
_Autre
Objet task
source.
Étant donné que task
se comporte comme un pointeur intelligent, après une assignation de copie, cet objet task
représente la même tâche réelle que _Other
.
Détermine si deux objets task
représentent la même tâche interne.
bool operator== (const task<_ResultType>& _Rhs) const;
bool operator== (const task<void>& _Rhs) const;
_Rhs
Tâche à comparer.
true
si les objets font référence à la même tâche sous-jacente et false
sinon.
Retourne le planificateur pour cette tâche.
scheduler_ptr scheduler() const;
Pointeur vers le planificateur
Construit un objet task
.
task();
template<typename T>
__declspec(
noinline) explicit task(T _Param);
template<typename T>
__declspec(
noinline) explicit task(T _Param, const task_options& _TaskOptions);
task(
const task& _Other);
task(
task&& _Other);
T
Type du paramètre à partir duquel la tâche doit être construite.
_Param
Paramètre à partir duquel la tâche doit être construite. Il peut s’agir d’un objet lambda, d’un task_completion_event<result_type>
objet de fonction ou d’un Windows ::Foundation ::IAsyncInfo si vous utilisez des tâches dans votre application Windows Runtime. L’objet lambda ou de fonction doit être un type équivalent à std::function<X(void)>
, où X peut être une variable de type result_type
, task<result_type>
ou un Windows ::Foundation ::IAsyncInfo dans les applications Windows Runtime.
_TaskOptions
Les options de tâche incluent le jeton d’annulation, le planificateur, etc.
_Autre
Objet task
source.
Le constructeur par défaut pour task
est uniquement présent pour permettre l’utilisation des tâches dans des conteneurs. Une tâche créée par défaut ne peut pas être utilisée tant que vous ne lui assignez pas une tâche valide. Les méthodes telles que get
, wait
ou then
lèvent une exception invalid_argument lorsqu’elles sont appelées sur une tâche construite par défaut.
Une tâche créée à partir d’un objet task_completion_event
s’achève (et ses continuations sont planifiées) lorsque l’événement d’achèvement de tâche est défini.
La version du constructeur qui accepte un jeton d’annulation crée une tâche qui peut être annulée en utilisant la classe cancellation_token_source
à partir de laquelle le jeton a été obtenu. Les tâches créées sans jeton d'annulation ne sont pas annulables.
Les tâches créées à partir d’une interface Windows::Foundation::IAsyncInfo
ou d’une expression lambda qui retourne une interface IAsyncInfo
atteignent leur état terminal lorsque l’opération ou l’action asynchrone Windows Runtime se termine. De même, les tâches créées à partir d’une lambda qui retourne un task<result_type>
état terminal atteint l’état du terminal lorsque la tâche interne atteint son état terminal, et non lorsque l’expression lambda retourne.
task
se comporte comme un pointeur intelligent dont le passage par valeur est sécurisé. Il est accessible par plusieurs threads sans nécessiter de verrous.
Les surcharges de constructeur qui prennent une interface Windows ::Foundation ::IAsyncInfo ou une interface lambda retournant une telle interface ne sont disponibles que pour les applications Windows Runtime.
Pour plus d’informations, consultez Parallélisme des tâches.
Ajoute une tâche de continuation à cette tâche.
template<typename _Function>
__declspec(
noinline) auto then(const _Function& _Func) const -> typename details::_ContinuationTypeTraits<_Function,
_ResultType>::_TaskOfType;
template<typename _Function>
__declspec(
noinline) auto then(const _Function& _Func,
const task_options& _TaskOptions) const -> typename details::_ContinuationTypeTraits<_Function,
_ResultType>::_TaskOfType;
template<typename _Function>
__declspec(
noinline) auto then(const _Function& _Func,
cancellation_token _CancellationToken,
task_continuation_context _ContinuationContext) const -> typename details::_ContinuationTypeTraits<_Function,
_ResultType>::_TaskOfType;
template<typename _Function>
__declspec(
noinline) auto then(const _Function& _Func,
const task_options& _TaskOptions = task_options()) const -> typename details::_ContinuationTypeTraits<_Function,
void>::_TaskOfType;
template<typename _Function>
__declspec(
noinline) auto then(const _Function& _Func,
cancellation_token _CancellationToken,
task_continuation_context _ContinuationContext) const -> typename details::_ContinuationTypeTraits<_Function,
void>::_TaskOfType;
_Fonction
Type de l’objet fonction qui sera appelé par cette tâche.
_Func
Fonction de continuation à exécuter lorsque cette tâche se termine. Cette fonction de continuation doit accepter comme entrée une variable result_type
ou task<result_type>
, où result_type
correspond au type du résultat produit par cette tâche.
_TaskOptions
Les options de la tâche incluent le jeton d'annulation, le planificateur et le contexte de continuation. Par défaut, les 3 options précédentes sont héritées de la tâche précédente.
_CancellationToken
Jeton d'annulation à associer à la tâche de continuation. Une tâche de continuation créée sans jeton d‘annulation hérite du jeton de son antécédent.
_ContinuationContext
Variable qui spécifie où la continuation doit s'exécuter. Cette variable est utile uniquement lorsqu’elle est utilisée dans une application UWP. Pour plus d’informations, consultez task_continuation_context
Tâche de continuation récemment créée. Le type de résultat de la tâche retournée est déterminé par l’élément retourné par _Func
.
Les surcharges qui then
prennent un fonctor ou lambda qui retourne une interface Windows ::Foundation ::IAsyncInfo, sont uniquement disponibles pour les applications Windows Runtime.
Pour plus d’informations sur l’utilisation des continuations de tâches pour composer un travail asynchrone, consultez Le parallélisme des tâches.
Attend que cette tâche atteigne un état terminal. Il est possible que wait
exécute la tâche inline si toutes les dépendances de tâches sont remplies et si elle n’a pas déjà été sélectionnée pour être exécutée par un processus de travail d’arrière-plan.
task_status wait() const;
Valeur task_status
qui peut être completed
ou canceled
. Si la tâche rencontre une exception pendant l‘exécution, ou si une exception y est propagée à partir d‘une tâche précédente, wait
lèvera cette exception.
Important
Dans une application plateforme Windows universelle (UWP), n’appelez wait
pas de code qui s’exécute sur le thread d’interface utilisateur. Sinon, le runtime lève concurrency::invalid_operation , car cette méthode bloque le thread actuel et peut provoquer le blocage de l'application. Toutefois, vous pouvez appeler la méthode concurrency::task::get pour recevoir le résultat de la tâche précédente dans une continuation basée sur des tâches.