Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Contextes

Ce document décrit le rôle des contextes pendant le runtime d'accès concurrentiel. Un thread joint à un planificateur porte le nom de contexte d'exécution, ou simplement de contexte. Le concurrency::wait fonction et le concurrency::Context classe permettent de contrôler le comportement de contextes. Utilisez la fonction wait pour interrompre le contexte actuel pendant une durée spécifiée. Utilisez la classe Context lorsque vous avez besoin d'exercer un contrôle plus important lorsque les contextes se bloquent, se débloquent et cèdent, ou lorsque vous souhaitez à surabonner le contexte actuel.

Conseil Conseil

Le runtime d'accès concurrentiel fournit un planificateur par défaut. Par conséquent, vous n'êtes pas tenu d'en créer un dans votre application. Étant donné que le planificateur de tâches vous aide à affiner les performances de vos applications, nous vous recommandons de commencer avec la Bibliothèque de modèles parallèles ou la Bibliothèque d'agents asynchrones si vous ne connaissez pas encore le runtime d'accès concurrentiel.

Le concurrency::wait fonction cède conjointement l'exécution du contexte actuel pour un nombre de millisecondes spécifié. Le runtime utilise la durée de cession pour effectuer d'autres tâches. Une fois le délai écoulé, le runtime replanifie le contexte pour l'exécution. Par conséquent, la fonction wait peut interrompre le contexte actuel pendant plus longtemps que la valeur prévue par le paramètre milliseconds.

Le passage de la valeur 0 (zéro) pour le paramètre milliseconds fait en sorte que le runtime interrompe le contexte actuel jusqu'à ce que tous les autres contextes actifs aient l'opportunité d'exécuter le travail. Cela vous permet de céder une tâche à toutes les autres tâches actives.

Ff829266.collapse_all(fr-fr,VS.110).gifExemple

Pour obtenir un exemple qui utilise la fonction wait pour céder le contexte actuel, et donc permettre à d'autres contextes de s'exécuter, consultez Comment : utiliser des groupes de planifications pour influencer l'ordre d'exécution.

Le concurrency::Context classe fournit une abstraction de programmation pour un contexte d'exécution et offre deux fonctionnalités importantes : la possibilité de bloquer, débloquer et donnent le contexte actuel en coopération et la possibilité d'oversubscribe le contexte actuel.

Ff829266.collapse_all(fr-fr,VS.110).gifBlocage coopératif

La classe Context vous permet de bloquer ou de céder le contexte d'exécution actuel. Le blocage ou la cession est utile lorsque le contexte actuel ne peut pas continuer car une ressource n'est pas disponible.

Le concurrency::Context::Block méthode bloque le contexte actuel. Un contexte bloqué cède ses ressources de traitement afin que le runtime puisse effectuer d'autres tâches. Le concurrency::Context::Unblock méthode débloque un contexte bloqué. La méthode Context::Unblock doit être appelée à partir d'un contexte différent de celui qui a appelé Context::Block. Le runtime lève concurrency::context_self_unblock si un contexte tente de débloquer lui-même.

En coopération, bloquer et débloquer un contexte, vous appelez généralement concurrency::Context::CurrentContext pour récupérer un pointeur vers le Context objet qui est associé à la thread en cours et enregistrer le résultat. Il faut ensuite appeler la méthode Context::Block pour bloquer le contexte actuel. Puis, il faut appeler Context::Unblock à partir d'un contexte distinct pour débloquer le contexte bloqué.

Vous devez faire correspondre chaque paire d'appels à Context::Block et Context::Unblock. Le runtime lève concurrency::context_unblock_unbalanced lors de la Context::Block ou Context::Unblock méthode est appelée de façon consécutive sans appel correspondant à l'autre méthode. Toutefois, vous n'êtes pas obligé d'appeler Context::Block avant d'appeler Context::Unblock. Par exemple, si un contexte appelle Context::Unblock avant qu'un autre contexte n'appelle Context::Block pour le même contexte, ce contexte reste non bloqué.

Le concurrency::Context::Yield méthode suspend l'exécution afin que le runtime peut effectuer d'autres tâches et puis replanifier le contexte d'exécution. Lorsque vous appelez la méthode Context::Block, le runtime ne replanifie pas le contexte.

Ff829266.collapse_all(fr-fr,VS.110).gifExemple

Pour obtenir un exemple qui utilise les méthodes Context::Block, Context::Unblock et Context::Yield pour implémenter une classe de sémaphore coopérative, consultez Comment : utiliser la classe Context pour implémenter un sémaphore coopératif.

Ff829266.collapse_all(fr-fr,VS.110).gifSurabonnement

Le planificateur par défaut crée un nombre de threads égal au nombre de threads matériels disponibles. Vous pouvez utiliser le surabonnement pour créer des threads supplémentaires pour un thread matériel donné.

Pour les opérations nécessitant de nombreuses ressources de calcul, le surabonnement ne monte généralement pas en charge car il introduit une charge supplémentaire. Toutefois, dans le cas de tâches présentant une forte latence, par exemple la lecture de données à partir d'un disque ou d'une connexion réseau, le surabonnement peut améliorer l'efficacité globale de certaines applications.

Remarque Remarque

Activer l'over-subscription uniquement à partir d'un thread qui a été créé par le Runtime de simultanéité. Le surabonnement n'a aucun effet lorsqu'il est appelé par un thread n'ayant pas été créé par le runtime (y compris le thread principal).

Pour activer l'over-subscription dans le contexte actuel, appelez le concurrency::Context::Oversubscribe méthode avec la _BeginOversubscription paramètre la valeur true. Lorsque vous activez le surabonnement sur un thread qui a été créé par le runtime d'accès concurrentiel, le runtime crée un thread supplémentaire. Une fois que toutes les tâches qui requièrent le surabonnement sont terminées, appelez Context::Oversubscribe avec le paramètre _BeginOversubscription défini à la valeur false.

Vous pouvez activer le surabonnement plusieurs fois à partir du contexte actuel, mais vous devez le désactiver le même nombre de fois. Le surabonnement peut également être imbriqué ; autrement dit, une tâche créée par une autre tâche qui utilise le surabonnement peut également surabonner son contexte. Toutefois, si une tâche imbriquée et son parent appartiennent au même contexte, seul l'appel le plus à l'extérieur à Context::Oversubscribe provoque la création d'un thread supplémentaire.

Remarque Remarque

Le runtime lève concurrency::invalid_oversubscribe_operation si over-subscription est désactivé avant est activé.

Ff829266.collapse_all(fr-fr,VS.110).gifExemple

Pour obtenir un exemple qui utilise le surabonnement pour compenser la latence provoquée par la lecture de données à partir d'une connexion réseau, consultez Comment : utiliser le surabonnement pour compenser la latence.

Ajouts de la communauté

AJOUTER
Afficher: