Introduction au multithreading en C #
Pour comprendre le multithreading en c #, comprenons d'abord ce qu'est un thread?
- Un fil est un processus léger.
- C'est un chemin d'exécution d'un programme.
- Il s'agit de la plus petite unité de traitement d'un système d'exploitation.
- Ainsi, un processus peut avoir plusieurs threads.
Ainsi, le multithreading est un processus qui contient plusieurs threads dans lequel chaque thread effectue une activité différente. Cela permet de gagner du temps car plusieurs tâches sont exécutées en même temps par différents threads. Il augmente l'utilisation du processeur et augmente l'efficacité d'une application. Cela fonctionne sur le concept de temps partagé.
Syntaxe avec explication
Thread first_thread_name = new Thread(new ThreadStart(method_to_be_executed1));
Thread second_thread_name = new Thread(new ThreadStart(method_to_be_executed2));
first_thread_name.Start();
second_thread_name.Start();
Pour créer un thread, nous devons créer un objet de classe Thread. Le constructeur de la classe Thread prend la référence de ThreadStart. ThreadStart est un délégué qui représente une méthode qui doit être exécutée lorsque le thread commence l'exécution.
Le thread commence l'exécution lorsque la méthode Start () est appelée.
Nous pouvons créer un thread sans utiliser le délégué ThreadStart comme indiqué dans la syntaxe ci-dessous:
Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();
Création de plusieurs threads en C #
Afin de créer des threads, nous devons importer l'espace de noms system.Threading. Nous pouvons créer et initialiser des threads à l'aide de la classe Thread.
Exemple d'utilisation de la classe de thread
using System;
using System.Threading;
public class MultiThreadingDemo
(
public static void Method1()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
public static void Main()
(
// Creating and initializing threads
Thread thread1 = new Thread(Method1);
Thread thread2 = new Thread(Method2);
//beginning thread execution
thread1.Start();
thread2.Start();
)
)
Production:
Exemple d'utilisation d'un délégué ThreadStart
using System;
using System.Threading;
public class MultiThreading
(
public static void Method1()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Thread thread1 = new Thread(new ThreadStart(MultiThreading.Method1 ) );
Thread thread2 = new Thread(new ThreadStart(MultiThreading.Method2 ) );
thread1.Start();
thread2.Start();
)
)
Production:
En C #, un programme contient toujours un thread, c'est-à-dire le thread principal. Lorsque nous créons d'autres threads, il devient un programme multithreading et en multithreading C #, il existe deux types de threads:
- Thread de premier plan : ce thread continue de s'exécuter jusqu'à ce qu'il termine son travail même si le thread principal se termine.
- Thread d'arrière-plan : Lorsque le thread principal se termine, le thread d'arrière-plan arrête également de s'exécuter et se termine avec le thread principal.
Méthodes avec exemples
Voyons quelques méthodes couramment utilisées de la classe Thread avec des exemples.
- Sleep (): Utilisé pour suspendre l'exécution du thread actuel pendant une période de temps spécifiée, afin que les autres threads commencent l'exécution.
Exemple:
using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 1; i <= 10; i++)
(
Console.WriteLine(i);
//suspending execution of current thread for 100 milliseconds
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
thread1.Start();
thread2.Start();
)
)
Production:
La sortie montre que les deux threads exécutés en parallèle.
- Abort (): Utilisé pour terminer le thread ou on peut dire qu'il est utilisé pour arrêter définitivement l'exécution du thread.
Exemple
using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 10; i++)
(
Console.WriteLine(i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Console.WriteLine("Threads start execution");
thread1.Start();
thread2.Start();
try
(
//terminating execution of thread using Abort()
thread1.Abort();
thread2.Abort();
Console.WriteLine("Threads execution terminated");
)
catch (ThreadAbortException threadAbortException)
(
Console.WriteLine(threadAbortException.ToString());
)
)
)
Production:
- Join (): permet de faire attendre tous les threads appelants jusqu'à ce que le thread actuel termine son exécution et se termine.
Exemple:
using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 5; i++)
(
Thread thread = Thread.CurrentThread;
Console.WriteLine(thread.Name +" : "+i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Thread thread3 = new Thread(new ThreadStart(multithreading.Display));
//Assigning names to threads using Name property
thread1.Name = "Thread1";
thread2.Name = "Thread2";
thread3.Name = "Thread3";
thread1.Start();
//Making Thread2 and Thread3 wait until Thread1 completes execution
thread1.Join();
thread2.Start();
thread3.Start();
)
)
Production:
Avantages du multithreading en C #
- Aide à maintenir une interface utilisateur réactive: Parfois, nous avons une méthode longue dans notre application. Dans ce cas, si nous rendons notre application multithread, alors un autre thread prend la responsabilité de l'exécution de cette méthode tandis que le thread principal peut se concentrer sur la réactivité de l'application. Ainsi, il ne gèlera pas notre application en donnant en temps voulu une réponse appropriée à l'utilisateur.
- Augmente les performances de l'application: si nous avons autant de threads qu'il y a de cœurs de processeur, chaque thread s'exécutera indépendamment, augmentant le nombre de calculs par seconde.
- Les threads minimisent l'utilisation des ressources système car ils partagent le même espace d'adressage.
- Il rend le code à la fois plus rapide et plus simple à la fois.
Conclusion - Multithreading en C #
La classe de thread fournit de nombreuses propriétés importantes telles que Priority, Name, IsAlive, background que nous pouvons utiliser dans notre application multithreading. La synchronisation des threads est une technique par laquelle un thread peut accéder à une ressource pendant un certain temps sans interrompre d'autres threads jusqu'à ce qu'il termine sa tâche.
Articles recommandés
Cela a été un guide pour le multithreading en C #. Ici, nous discutons également de leur introduction, de la syntaxe, de la création et des exemples de multithreading en c #. Vous pouvez également consulter les articles suivants pour en savoir plus–
- Objets en C #
- Destructeur en C #
- Destructeur en C #
- Héritage en C #
- Destructeur en PHP | Exemples