Guide de démarrage sur le multithreading en C

Bonjour à tous, futurs développeurs C# ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde du multithreading. Ne vous inquiétez pas si cela semble intimidant - je serai votre guide amical, et nous avancerons pas à pas. À la fin de ce tutoriel, vous serez capable de gérer des threads comme un pro !

Qu'est-ce que le multithreading ?

Avant de plonger dedans, comprenons ce qu'est le multithreading. Imaginez que vous cuisinez un repas complexe. Vous ne feriez pas une tâche à la fois, n'est-ce pas ? Vous pourriez avoir de la pasta qui bout sur une plaque de cuisson, pendant que vous coupez des légumes et surveillez la sauce. C'est du multitasking, et dans le monde de la programmation, on l'appelle multithreading.

Le multithreading permet à un programme d'exécuter plusieurs tâches simultanément. C'est comme avoir plusieurs cuisiniers dans la cuisine, chacun responsable d'une partie différente du repas.

Cycle de vie d'un thread

Comme nous les humains, les threads ont un cycle de vie. Voici une brève description :

1. Naissance (New) : Le thread est créé mais pas encore démarré.
2. Prêt (Ready) : Le thread est prêt à s'exécuter et attend le temps processeur.
3. Exécution (Running) : Le thread exécute sa tâche.
4. Bloqué (Blocked) : Le thread est temporairement en pause (peut-être en attente d'une ressource).
5. Mort (Dead) : Le thread a terminé sa tâche et ne s'exécute plus.

Voici une simple visualisation :

New -> Ready -> Running -> Dead
^        |
|        v
<-- Blocked

Le thread principal

Lorsque vous démarrez un programme C#, il crée automatiquement un thread appelé le Main Thread. C'est comme le chef principal dans notre analogie de cuisine. Voici comment il fonctionne :

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Console.WriteLine("Thread principal : " + Thread.CurrentThread.ManagedThreadId);
}
}

Lorsque vous exécutez ceci, vous verrez quelque chose comme :

Thread principal : 1

Cela montre que notre programme s'exécute sur le Main Thread, qui a toujours un ID de 1.

Propriétés et méthodes de la classe Thread

La classe Thread en C# vient avec un tas de propriétés et de méthodes utiles. Jetons un œil aux plus courantes :

Propriété/Méthode	Description
ManagedThreadId	Obtient l'identifiant unique du thread
IsAlive	Indique si ce thread a été démarré et n'a pas terminé
Name	Obtient ou définit le nom du thread
Priority	Obtient ou définit la priorité de planification du thread
Start()	Démarrage du thread
Sleep()	Suspend le thread pendant un temps spécifié
Join()	Bloque le thread d'appel jusqu'à ce que ce thread se termine

Voici quelques exemples en action :

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Thread t = new Thread(DoWork);
t.Name = "Thread ouvrier";
Console.WriteLine("Démarrage du thread...");
t.Start();
t.Join();
Console.WriteLine("Thread terminé");
}

static void DoWork()
{
Console.WriteLine($"Thread {Thread.CurrentThread.Name} est en train de travailler");
Thread.Sleep(1000);
Console.WriteLine($"Thread {Thread.CurrentThread.Name} a terminé de travailler");
}
}

Ce programme crée un nouveau thread, le nomme, le démarre, attend sa fin, puis continue. La sortie sera :

Démarrage du thread...
Thread Thread ouvrier est en train de travailler
Thread Thread ouvrier a terminé de travailler
Thread terminé

Création de threads

Créer des threads en C# est comme embaucher de nouveaux cuisiniers pour notre cuisine. Voici comment nous le faisons :

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
// Créer un thread en utilisant une méthode nommée
Thread t1 = new Thread(DoWork);
t1.Start();

// Créer un thread en utilisant une méthode anonyme
Thread t2 = new Thread(() =>
{
Console.WriteLine("Thread 2 est en train de travailler");
});
t2.Start();

// Créer un thread avec des paramètres
Thread t3 = new Thread(param =>
{
Console.WriteLine($"Thread 3 dit : {param}");
});
t3.Start("Bonjour de Thread 3 !");
}

static void DoWork()
{
Console.WriteLine("Thread 1 est en train de travailler");
}
}

Cet exemple montre trois différentes manières de créer des threads. Exécutez-le et voyez ce qui se passe !

Gestion des threads

Gérer les threads est crucial pour un multithreading efficace. Jetons un œil à quelques moyens de le faire :

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Thread t = new Thread(DoWork);
t.Start();

// Attendre que le thread se termine
t.Join();

// Définir la priorité du thread
t.Priority = ThreadPriority.Highest;

// Vérifier si le thread est vivant
Console.WriteLine($"Le thread est-il vivant ? {t.IsAlive}");

// Mettre le thread principal en veille
Thread.Sleep(1000);
}

static void DoWork()
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine($"Travail... {i}");
Thread.Sleep(500);
}
}
}

Cet exemple demonstrates comment attendre que le thread se termine, définir sa priorité, vérifier son état, et mettre un thread en veille.

Destruction des threads

En C#, nous ne "détruisons" pas généralement les threads manuellement. Les threads se terminent automatiquement lorsqu'ils terminent leur travail ou lorsque l'application quitte. Cependant, nous pouvons demander à un thread de s'arrêter en utilisant la méthode Abort(), bien que ce ne soit généralement pas recommandé en raison de problèmes potentiels avec le nettoyage des ressources.

Voici un exemple d'utilisation de Abort(), mais souvenez-vous, il est préférable de concevoir vos threads pour qu'ils se terminent naturellement :

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Thread t = new Thread(DoWork);
t.Start();

Thread.Sleep(2000); // Laisser le thread s'exécuter pendant 2 secondes

t.Abort(); // Arrêter le thread
Console.WriteLine("Thread arrêté");
}

static void DoWork()
{
while (true)
{
Console.WriteLine("Travaillant...");
Thread.Sleep(500);
}
}
}

Cela fera fonctionner le thread pendant environ 2 secondes avant de l'arrêter.

Et voilà ! Vous avez刚刚 terminé votre première leçon sur le multithreading en C#. Souvenez-vous, comme apprendre à cuisiner, maîtriser le multithreading nécessite de la pratique. Alors n'ayez pas peur d'expérimenter avec ces concepts. Bon codage, et puissent vos threads toujours s'exécuter en douceur !

Credits: Image by storyset