C# - Multithreading
Un fil est défini comme le chemin d'exécution d'un programme. Chaque thread définit un flux de contrôle unique. Si votre application implique des opérations compliquées et chronophages, il est souvent utile de définir différents chemins d'exécution ou threads, chaque thread effectuant une tâche particulière.
Les threads sont des processus légers . Un exemple courant d'utilisation de thread est la mise en œuvre de la programmation concurrente par les systèmes d'exploitation modernes. L'utilisation de threads évite le gaspillage du cycle CPU et augmente l'efficacité d'une application.
Jusqu'à présent, nous avons écrit les programmes où un seul thread s'exécute comme un seul processus qui est l'instance en cours d'exécution de l'application. Cependant, de cette façon, l'application peut effectuer une tâche à la fois. Pour lui faire exécuter plus d'une tâche à la fois, il pourrait être divisé en plus petits threads.
Cycle de vie du fil
Le cycle de vie d'un thread commence lorsqu'un objet de la classe System.Threading.Thread est créé et se termine lorsque le thread est terminé ou termine son exécution.
Voici les différents états du cycle de vie d'un thread −
-
L'état non démarré − C'est la situation où l'instance du thread est créée mais la méthode Start n'est pas appelée.
-
L'état prêt − C'est la situation où le thread est prêt à fonctionner et attend le cycle CPU.
-
L'état non exécutable − Un thread n'est pas exécutable, quand
- La méthode Sleep a été appelée
- La méthode Wait a été appelée
- Bloqué par les opérations d'E/S
-
L'état mort − C'est la situation où le thread termine son exécution ou est abandonné.
Le fil principal
En C#, le System.Threading.Thread La classe est utilisée pour travailler avec les threads. Il permet de créer et d'accéder à des threads individuels dans une application multithread. Le premier thread à exécuter dans un processus est appelé main fil.
Lorsqu'un programme C# démarre son exécution, le thread principal est automatiquement créé. Les discussions créées à l'aide de Thread sont appelés les threads enfants du thread principal. Vous pouvez accéder à un fil à l'aide de CurrentThread propriété de la classe Thread.
Le programme suivant illustre l'exécution du thread principal −
Démo en direct
using System;
using System.Threading;
namespace MultithreadingApplication {
class MainThreadProgram {
static void Main(string[] args) {
Thread th = Thread.CurrentThread;
th.Name = "MainThread";
Console.WriteLine("This is {0}", th.Name);
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
This is MainThread
Propriétés et méthodes de la classe Thread
Le tableau suivant montre quelques propriétés les plus couramment utilisées du fil classe −
| Sr.No. | Propriété et description |
|---|---|
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | |
| 9 | |
| 10 | |
| 11 | |
| 12 | |
| 13 |
Le tableau suivant présente certaines des méthodes les plus couramment utilisées du fil classe −
| Sr.No. | Méthode et description |
|---|---|
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | |
| 9 | |
| 10 | |
| 11 | |
| 12 | |
| 13 | |
| 14 | |
| 15 | |
| 16 | |
| 17 | |
| 18 | |
| 19 | |
| 20 | |
| 21 | |
| 22 | |
| 23 |
Créer des sujets
Les threads sont créés en étendant la classe Thread. La classe Thread étendue appelle alors Start() méthode pour commencer l'exécution du thread enfant.
Le programme suivant illustre le concept −
Démo en direct
using System;
using System.Threading;
namespace MultithreadingApplication {
class ThreadCreationProgram {
public static void CallToChildThread() {
Console.WriteLine("Child thread starts");
}
static void Main(string[] args) {
ThreadStart childref = new ThreadStart(CallToChildThread);
Console.WriteLine("In Main: Creating the Child thread");
Thread childThread = new Thread(childref);
childThread.Start();
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
In Main: Creating the Child thread Child thread starts
Gestion des fils
La classe Thread fournit diverses méthodes de gestion des threads.
L'exemple suivant illustre l'utilisation de sleep() méthode pour mettre un thread en pause pendant une période de temps spécifique.
Démo en direct
using System;
using System.Threading;
namespace MultithreadingApplication {
class ThreadCreationProgram {
public static void CallToChildThread() {
Console.WriteLine("Child thread starts");
// the thread is paused for 5000 milliseconds
int sleepfor = 5000;
Console.WriteLine("Child Thread Paused for {0} seconds", sleepfor / 1000);
Thread.Sleep(sleepfor);
Console.WriteLine("Child thread resumes");
}
static void Main(string[] args) {
ThreadStart childref = new ThreadStart(CallToChildThread);
Console.WriteLine("In Main: Creating the Child thread");
Thread childThread = new Thread(childref);
childThread.Start();
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
In Main: Creating the Child thread Child thread starts Child Thread Paused for 5 seconds Child thread resumes
Détruire les fils
Le Abandonner() méthode est utilisée pour détruire les threads.
Le runtime abandonne le thread en lançant une ThreadAbortException . Cette exception ne peut pas être interceptée, le contrôle est envoyé au finalement bloquer, le cas échéant.
Le programme suivant illustre cela −
Démo en direct
using System;
using System.Threading;
namespace MultithreadingApplication {
class ThreadCreationProgram {
public static void CallToChildThread() {
try {
Console.WriteLine("Child thread starts");
// do some work, like counting to 10
for (int counter = 0; counter <= 10; counter++) {
Thread.Sleep(500);
Console.WriteLine(counter);
}
Console.WriteLine("Child Thread Completed");
} catch (ThreadAbortException e) {
Console.WriteLine("Thread Abort Exception");
} finally {
Console.WriteLine("Couldn't catch the Thread Exception");
}
}
static void Main(string[] args) {
ThreadStart childref = new ThreadStart(CallToChildThread);
Console.WriteLine("In Main: Creating the Child thread");
Thread childThread = new Thread(childref);
childThread.Start();
//stop the main thread for some time
Thread.Sleep(2000);
//now abort the child
Console.WriteLine("In Main: Aborting the Child thread");
childThread.Abort();
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
In Main: Creating the Child thread Child thread starts 0 1 2 In Main: Aborting the Child thread Thread Abort Exception Couldn't catch the Thread Exception
Langue C