Applications multithread (C# et Visual Basic)

Article
06/10/2015

Visual Basic et C# vous permettent d'écrire des applications pouvant exécuter simultanément plusieurs tâches. Les tâches ayant la particularité de pouvoir suspendre d'autres tâches peuvent s'exécuter sur des threads séparés ; ce processus est connu sous le nom de multithreading ou traitement dissocié des threads.

Les applications qui utilisent le multithreading réagissent mieux aux entrées d'utilisateur parce que leur interface utilisateur reste active pendant que les tâches qui sollicitent beaucoup le processeur s'exécutent sur des threads séparés. Le multithreading est également utile lorsqu'il s'agit de créer des applications évolutives, parce qu'il vous est possible d'ajouter des threads en fonction de l'augmentation de la charge de travail.

Notes

Visual Studio 2010 et le .NET Framework 4 améliorent la prise en charge de la programmation parallèle en fournissant un nouveau runtime, de nouveaux types de bibliothèques de classes et de nouveaux outils de diagnostics.Pour plus d’informations, consultez Programmation parallèle dans le .NET Framework.

Utilisation du composant BackgroundWorker

La méthode la plus fiable pour créer une application multithread consiste à utiliser le composant BackgroundWorker. Cette classe gère un thread distinct dédié au traitement de la méthode spécifiée. Pour obtenir un exemple, consultez Procédure pas à pas : multithreading avec le composant BackgroundWorker (C# et Visual Basic).

Pour démarrer une opération en arrière-plan, créez un objet BackgroundWorker et écoutez les événements qui indiquent la progression de votre opération et lorsque celle-ci se termine. Vous pouvez créer l'objet BackgroundWorker par programmation, ou vous pouvez le déplacer dans le formulaire à partir de l'onglet Composants de la Boîte à outils. Si vous créez l'objet BackgroundWorker dans le Concepteur Forms, il apparaît dans la Barre d'état des composants, et ses propriétés sont affichées dans la fenêtre Propriétés.

Configuration d'une opération d'arrière-plan

Pour configurer une opération d'arrière-plan, ajoutez un gestionnaire d'événements pour l'événement DoWork. Appelez votre longue opération dans ce gestionnaire d'événements.

Pour démarrer l'opération, appelez RunWorkerAsync. Pour recevoir la notification des mises à jour de progression, traitez l'événement ProgressChanged. Pour recevoir une notification lorsque l'opération est terminée, gérez l'événement RunWorkerCompleted.

Les méthodes qui gèrent les événements ProgressChanged et RunWorkerCompleted peuvent accéder à l'interface utilisateur de l'application, car ces événements sont déclenchés sur le thread qui a appelé la méthode RunWorkerAsync. Toutefois, le gestionnaire d'événements DoWork ne peut pas utiliser les objets d'interface utilisateur car il s'exécute sur le thread d'arrière-plan.

Création et utilisation de threads

Si vous avez besoin d'un plus grand contrôle sur le comportement des threads de votre application, vous pouvez gérer vous-même les threads. Toutefois, n'oubliez pas que l'écriture d'applications multithread correctes peut s'avérer difficile : votre application peut cesser de répondre ou rencontrer des erreurs transitoires dues aux conditions de concurrence critique. Pour plus d’informations, consultez Composants thread-safe.

Pour créer un thread, vous déclarez une variable de type Thread et appelez le constructeur en fournissant le nom de la procédure ou de la méthode que vous voulez exécuter sur le nouveau thread. Le code suivant en est un exemple.

Dim newThread As New System.Threading.Thread(AddressOf AMethod)

System.Threading.Thread newThread =
    new System.Threading.Thread(AMethod);

Démarrage et interruption de threads

Pour démarrer l'exécution d'un nouveau thread, utilisez la méthode Start, comme indiqué dans le code suivant.

newThread.Start()

newThread.Start();

Pour arrêter l'exécution d'un thread, utilisez la méthode Abort, comme indiqué dans le code suivant.

newThread.Abort()

newThread.Abort();

Vous pouvez non seulement démarrer et arrêter des threads, mais également les interrompre en appelant la méthode Sleep ou Suspend, redémarrer un thread interrompu avec la méthode Resume et détruire un thread à l'aide de la méthode Abort.

Méthodes de thread

Le tableau suivant présente quelques méthodes qui permettent de contrôler des threads individuels.

Méthode	Action
Start	Déclenche le démarrage d'un thread.
Sleep	Suspend un thread pendant un délai déterminé.
Suspend	Suspend un thread lorsque celui-ci atteint un point sûr.
Abort	Arrête un thread lorsque celui-ci atteint un point sûr.
Resume	Redémarre un thread suspendu.
Join	Force le thread actif à attendre la fin de l'exécution d'un autre thread. Utilisée avec un délai d'attente, cette méthode retourne la valeur True si le thread se termine dans les temps impartis.

Points sûrs

La plupart de ces méthodes sont explicatives, mais le concept de point sûr peut être nouveau pour vous. Les points sûrs sont des emplacements de code où le Common Language Runtime peut effectuer en toute sécurité une opération automatique de garbage collection, qui consiste à libérer des variables inutilisées et à récupérer l'espace mémoire correspondant. Lorsque vous appelez la méthode Abort ou Suspend d'un thread, le Common Language Runtime analyse le code et détermine le point approprié pour l'arrêt du thread.

Propriétés de thread

Les threads contiennent également plusieurs propriétés utiles, décrites dans le tableau suivant :

Property	Valeur
IsAlive	Contient la valeur True si un thread est actif.
IsBackground	Obtient ou définit une valeur Boolean qui indique si un thread est ou doit être un thread d'arrière-plan. Les threads d'arrière-plan ressemblent aux threads de premier plan, mais ils n'empêchent pas l'arrêt d'un processus. Lorsque tous les threads de premier plan appartenant à un processus se sont arrêtés, le Common Language Runtime met fin au processus par l'appel de la méthode Abort sur les threads d'arrière-plan restés actifs.
Name	Obtient ou définit le nom d'un thread. Sert le plus souvent à découvrir des threads individuels lors du débogage.
Priority	Obtient ou définit une valeur utilisée par le système d'exploitation pour classer par ordre de priorité la planification des threads.
ApartmentState	Obtient ou définit le modèle de thread utilisé pour un thread particulier. Les modèles de thread sont importants lorsqu'un thread appelle du code non managé.
ThreadState	Contient une valeur qui décrit l'état ou les états d'un thread.

Priorités associées aux threads

Chaque thread a une propriété Priority, qui détermine le temps processeur dont il dispose pour s'exécuter. Plus le degré de priorité est élevé, plus les plages de temps affectées aux threads par le système d'exploitation sont importantes. Les nouveaux threads sont créés avec la valeur Normal, mais vous pouvez affecter à la propriété Priority une autre valeur dans l'énumération ThreadPriority.

Consultez ThreadPriority pour obtenir une description détaillée des différentes priorités des threads.

Threads de premier plan et d'arrière-plan

Un thread de premier plan peut s'exécuter indéfiniment, tandis qu'un thread d'arrière-plan prend fin dès l'arrêt du dernier thread de premier plan. Vous pouvez utiliser la propriété IsBackground pour déterminer ou changer l'état d'arrière-plan d'un thread.

Multithreading avec des formulaires et contrôles

Outre le fait que le multithreading soit la solution la mieux adaptée aux procédures en cours d'exécution et aux méthodes de classe, vous pouvez également l'utiliser avec des formulaires et des contrôles. Si vous choisissez de l'utiliser de cette façon, tenez bien compte des points suivants :

Autant que possible, n'exécutez les méthodes d'un contrôle que sur le thread avec lequel ce contrôle a été créé. Si vous avez besoin d'appeler une méthode d'un contrôle à partir d'un autre thread, vous devez utiliser Invoke.
N'utilisez pas l'instruction SyncLock (Visual Basic) ou lock (C#) pour verrouiller des threads qui manipulent des contrôles ou des formulaires. Comme les méthodes des contrôles et formulaires rappellent parfois une procédure d'appel, vous risquez de créer sans vous en rendre compte un interblocage ; dans cette situation, deux threads attendent chacun que l'autre annule le verrou, ce qui entraîne l'arrêt de l'application.

Voir aussi

Partager via