Comment utiliser le multithread avec des tâches en C #

Le terme de programmation informatique "thread" est l'abréviation de thread d'exécution, dans lequel un processeur suit un chemin spécifié à travers votre code. Le concept de suivre plusieurs threads à la fois introduit le sujet du multitâche et du multithread.

Une application contient un ou plusieurs processus. Considérez un processus comme un programme exécuté sur votre ordinateur. Maintenant, chaque processus a un ou plusieurs threads. Une application de jeu peut avoir un thread pour charger des ressources à partir du disque, un autre pour faire de l'IA et un autre pour exécuter le jeu en tant que serveur..

Dans .NET / Windows, le système d'exploitation alloue du temps processeur à un thread. Chaque thread garde une trace des gestionnaires d'exceptions et de la priorité à laquelle il s'exécute, et il a un endroit pour enregistrer le contexte du thread jusqu'à ce qu'il s'exécute. Le contexte du thread est l'information que le thread doit reprendre.

Multi-tâches avec des threads

Les threads prennent un peu de mémoire et leur création prend un peu de temps, donc généralement, vous ne voulez pas en utiliser beaucoup. N'oubliez pas, ils se disputent le temps processeur. Si votre ordinateur possède plusieurs processeurs, Windows ou .NET peut exécuter chaque thread sur un processeur différent, mais si plusieurs threads s'exécutent sur le même CPU, alors un seul peut être actif à la fois et le changement de threads prend du temps.

Le processeur exécute un thread pour quelques millions d'instructions, puis il passe à un autre thread. Tous les registres du processeur, le point d'exécution du programme actuel et la pile doivent être enregistrés quelque part pour le premier thread, puis restaurés ailleurs pour le prochain thread.

Créer un fil

Dans le système d'espace de noms. Enfilant, vous trouverez le type de fil. Le thread constructeur (ThreadStart) crée une instance d'un thread. Cependant, dans le code C # récent, il est plus probable de passer une expression lambda qui appelle la méthode avec tous les paramètres.

Si vous n'êtes pas sûr des expressions lambda, il peut être utile de consulter LINQ.

Voici un exemple de thread créé et démarré:

en utilisant le système;

en utilisant System.Threading;
espace de noms ex1

Programme de cours

public static void Write1 ()

Console.Write ('1');
Thread.Sleep (500);

statique void Main (chaîne [] args)

var task = nouveau Thread (Write1);
task.Start ();
pour (var i = 0; i < 10; i++)

Console.Write ('0');
Console.Write (task.IsAlive? 'A': 'D');
Thread.Sleep (150);

Console.ReadKey ();

Tout cet exemple ne fait qu'écrire "1" sur la console. Le thread principal écrit un «0» sur la console 10 fois, suivi à chaque fois d'un «A» ou d'un «D» selon que l'autre thread est toujours vivant ou mort..

L'autre thread s'exécute une seule fois et écrit un «1». Après le délai d'une demi-seconde dans le thread Write1 (), le thread se termine et le Task.IsAlive dans la boucle principale renvoie désormais "D."

Pool de threads et bibliothèque parallèle de tâches

Au lieu de créer votre propre thread, sauf si vous en avez vraiment besoin, utilisez un Thread Pool. À partir de .NET 4.0, nous avons accès à la bibliothèque parallèle de tâches (TPL). Comme dans l'exemple précédent, encore une fois, nous avons besoin d'un peu de LINQ, et oui, ce sont toutes des expressions lambda.

Tâches utilise le Thread Pool en arrière-plan mais utilise mieux les threads en fonction du nombre utilisé.

L'objet principal du TPL est une tâche. Il s'agit d'une classe qui représente une opération asynchrone. La façon la plus courante de démarrer les choses est avec Task.Factory.StartNew comme dans: