Multithreading en C# : avantages, principes de base et meilleures pratiques

Qu'est-ce que la programmation multithread

Le multithreading est un concept fondamental en génie logiciel. En C#, la programmation multithread est essentielle pour les développeurs de logiciels travaillant avec le .NET Framework. Les développeurs utilisent largement le multithreading en C# car il leur permet de créer efficacement des applications complexes et réactives.

Ce blog donne un aperçu du multithreading c# tout en examinant également comment les programmeurs peuvent créer et gérer facilement des threads. Il inclut également les avantages de l'utilisation du multithreading et des différents modèles de threading disponibles en C#.

Bénéfices et avantages de la programmation multithread

Lorsqu'il est exécuté simultanément, le multithreading améliore l'efficacité des applications. Les avantages les plus courants du thread C# sont les suivants :

• Amélioration des performances des applications : grâce au multithreading, les applications s'exécutent plus rapidement avec plusieurs tâches exécutées dans le même espace.Dans sa totalité, il réduit le temps d'exécution et laisse place à de multiples tâches.
• Débit accru : le multitâche en C# améliore le débit des applications.Lorsque deux threads différents s'exécutent simultanément, cela peut économiser du temps et des ressources.
• Amélioration de la réactivité : grâce au multithreading, un utilisateur peut accéder au front-end de l'application pendant que le programme s'exécute en arrière-plan.
• Utilisation accrue des ressources : le multithreading permet aux utilisateurs d'accéder plus efficacement aux ressources système.Par exemple, les threads peuvent partager des ressources telles que des fichiers, de la mémoire et des périphériques d'E/S, ouvrant la voie à l'efficacité.
• Programmation plus accessible : le multithreading permet une programmation plus facile car les utilisateurs peuvent écrire des threads indépendamment.Il permet également aux utilisateurs de déboguer et de tester des applications de manière isolée.
• Communication optimisée : la synchronisation des threads permet une meilleure communication de processus à processus.Il peut être utilisé pour une communication plus accessible entre les threads.

Premièrement, cela affecte des objets uniques qui peuvent être synchronisés. Deuxièmement, il peut être utilisé avec les classes System.Threading et Interlocked.

Concepts de base du multithreading en C#

Le multithreading permet aux utilisateurs d'effectuer plusieurs tâches simultanément à l'aide de plusieurs cœurs de processeur. Voici les concepts de base utilisés en multithreading :

• Threads : les threads sont les unités de base du multithreading qui aident à exécuter un processus.Ce sont des chemins d'exécution dans un programme donné qui peuvent s'exécuter simultanément avec d'autres threads.

En C #, nous pouvons trouver deux types de threads, à savoir les threads de premier plan et d'arrière-plan. La classe de thread moyenne comprend un nom, une priorité, isAlive, ThreadState, Start(), Suspend(), Resume() et Join().

• Pool de threads : un pool de threads est un thread qui permet d'exécuter des tâches.Il permet au système d'exploitation de réutiliser les threads existants et minimise le risque d'éventuelles surcharges.
• Synchronisation : la synchronisation néglige l'accès à d'autres threads pour plusieurs opérations.Il s'agit d'un processus essentiel pour maintenir l'intégrité des données et éviter les frais généraux.
• Interblocage : un interblocage est une erreur qui se produit lorsque deux threads partagent des ressources et tentent de continuer sans succès.Cela peut provoquer le blocage du système ou même entraîner un temps d'attente.
• Programmation asynchrone : la programmation asynchrone permet d'exécuter plusieurs tâches en arrière-plan tout en permettant au thread principal de s'exécuter sans interruption.Il ouvre la voie à plusieurs interfaces utilisateur réactives, améliorant les performances des applications.

Création et exécution de threads

La création et l'exécution peuvent être plus faciles avec ces exemples. Un exemple de multithreading C# est donné ci-dessous :

utiliser le système ;

en utilisant System.Threading ;

programme de classe {

vide statique Principal() {

int workerIndex = 0;

Thread workerThread = new Thread(new ThreadStart(Worker));

workerThread.Start();

for (int mainIndex = 1; mainIndex <= 10; mainIndex++) {

Console.WriteLine("Thread principal : {0}", mainIndex);

Thread.Sleep(200);

}

workerThread.Join();

}

travailleur vide statique () {

for (int indexouvrier = 1; indexouvrier <= 10; indexouvrier++) {

Console.WriteLine("Fil de travail : {0}", workerIndex * 2);

Thread.Sleep(200);

}

}

}

Sortir:

Fil principal : 1

Fil de travail : 2

Fil principal : 2

Fil de travail : 4

Fil principal : 3

Fil de travail : 6

Fil principal : 4

Fil de travail : 8

Fil principal : 5

Fil de travail : 10

Fil principal : 6

Fil de travail : 12

Fil principal : 7

Fil de travail : 14

Fil principal : 8

Fil de travail : 16

Fil principal : 9

Fil de travail : 18

Fil principal : 10

Fil de travail : 20

Explication : Dans cette sortie, les deux threads fonctionnent simultanément pour imprimer les numéros 1 à 10 et 2 à 20, ce dernier doublé à partir de l'index de boucle.Dans cet exemple, la méthode thread sleep C# (Thread.Sleep) a été utilisée.

De la même manière, nous allons regarder un autre exemple de thread C# utilisant le thread de premier plan :

utiliser le système ;

en utilisant System.Threading ;

programme de classe {

vide statique Principal() {

Thread myThread = new Thread(Worker);

monThread.Start();

Console.WriteLine("Thread principal : démarré");

pour (entier je = 1; je <= 5; je++) {

Console.WriteLine("Thread principal : Compter {0}", i);

Thread.Sleep(500);

}

Console.WriteLine("Thread principal : terminé");

}

travailleur vide statique () {

pour (dans j = 1; j <= 5; j++) {

Console.WriteLine("Thread Worker : Count {0}", j * 3);

Thread.Sleep(750);

}

Console.WriteLine("Fil de travail : terminé");

}

}

Sortir:

Sujet principal : commencé

Fil de travail : compte 3

Fil principal : compte 1

Fil de travail : compte 6

Fil principal : compte 2

Fil de discussion : compte 9

Fil principal : comptez 3

Fil de travail : Comptez 12

Fil principal : comptez 4

Fil d'ouvrier : comptez 15

Fil principal : Comptez 5

Sujet de travail : terminé

Sujet principal : terminé

Explication : Cette sortie montre comment les deux unités d'exécution fonctionnent simultanément.Comme les threads principaux et d'arrière-plan fonctionnent en parallèle, le thread principal imprime des nombres de 1 à 5. Le thread de travail imprime des multiples de 3 à 15.

Consultez les cours de développement de logiciels chez upGrad pour améliorer vos compétences.

Lisez nos articles populaires liés au développement de logiciels

Synchronisation des threads

La synchronisation des threads implique la coordination collective de plusieurs threads dans un programme. Il assure que le programme est exécuté dans un ordre précis donnant accès aux ressources partagées.

En C#, cela se fait à l'aide de primitives de synchronisation telles que le mot-clé lock, les objets de synchronisation et la classe Interlocked.

Un exemple de synchronisation de thread C# est donné ci-dessous :

Utilisation du système ;

Utilisation de System.Threading ;

classe TablePrinter

{

public void PrintTable()

{

verrouiller (ceci)

{

pour (int i = 3; i <= 8; i++)

{

Thread.Sleep(200);

Console.WriteLine(i*5);

}

}

}

}

Programme de classe

{

public static void Main(string[] args)

{

TablePrinter tp = new TablePrinter();

Thread t1 = nouveau Thread(nouveau ThreadStart(tp.PrintTable));

Thread t2 = nouveau Thread(new ThreadStart(tp.PrintTable));

t1.Début();

t2.Début();

}

}

Sortir:

15

20

25

30

35

40

45

50

55

60

Explorez nos cours gratuits de développement de logiciels

Blocages

Les interblocages dans le multithreading se produisent lorsqu'au moins deux threads ou plus dépendent d'un ensemble de ressources. Lorsqu'un thread chevauche la route vers l'aide tandis que l'autre essaie de faire de même, cela devient une impasse.

Par exemple, si le thread A a un verrou sur la ressource 1 et attend d'accéder à la ressource 2 tandis que le thread B attend la ressource 1, cela peut entraîner un blocage.

Un exemple est donné ci-dessous:

utiliser le système ;

en utilisant System.Threading ;

espace de noms deadlockincsharp

{

classe publique Exemple

{

objet statique en lecture seule firstLock = new object();

objet statique en lecture seule secondLock = new object();

statique vide ThreadJob()

{

Console.WriteLine("\t\t\t\tVerrouiller le premier verrou");

verrouiller (firstLock)

{

Console.WriteLine("\t\t\t\tLocked firstLock");

Thread.Sleep(1500);

Console.WriteLine("\t\t\t\tVerrouillage secondLock");

verrouiller (secondLock)

{

Console.WriteLine("\t\t\t\tLocked secondLock");

}

Console.WriteLine("\t\t\t\tReleased secondLock");

}

Console.WriteLine("\t\t\t\tReleased firstLock");

}

vide statique Main()

{

nouveau Thread(nouveau ThreadStart(ThreadJob)).Start();

Thread.Sleep(1000);

Console.WriteLine("Verrouillage secondLock");

verrouiller (secondLock)

{

Console.WriteLine("SecondLock verrouillé");

Console.WriteLine("Verrouillage firstLock");

verrouiller (firstLock)

{

Console.WriteLine("Verrouillé firstLock");

}

Console.WriteLine("FirstLock libéré");

}

Console.WriteLine("SecondLock libéré");

Console.Read();

}

}

}

Sortir:

Verrouillage secondLock

Verrouillé secondLock

Verrouiller d'abordVerrouiller

Verrouillé en premierVerrouiller

Libéré en premierLock

Libéré secondLock

Compétences en développement de logiciels à la demande

Pools de threads

Les pools de threads permettent de gérer plusieurs threads d'exécution dans un environnement multithread en C#. Ceux-ci garantissent que tous les threads ont accès à des ressources contrôlées sans provoquer de blocages.

Un gestionnaire de pool de threads s'occupe du pool de threads, où il est responsable de la création, de la destruction et de la planification des threads.

Voici un exemple de pool de threads utilisant TPL (Task Parallel Library) :

utiliser le système ;

en utilisant System.Threading.Tasks ;

Programme de classe

{

vide statique Main()

{

Tâche<chaîne> tâche = Task.Factory.StartNew<chaîne>

(() => TéléchargerChaîne("http://www.exemple.com/"));

résultat de chaîne = tâche.Résultat ;

Console.WriteLine(result);

Console.Read();

}

chaîne statique DownloadString(chaîne uri)

{

en utilisant (var wc = new System.Net.WebClient())

return wc.DownloadString(uri);

}

Sortir:

La sortie dépend du contenu disponible sur la page Web. Ce programme assurera le téléchargement du contenu de la page Web à partir de l'URL spécifiée. Il les imprimera ensuite.

Programmation asynchrone avec la bibliothèque parallèle de tâches (TPL)

La bibliothèque parallèle de tâches (TPL) est un outil puissant pour gérer les API et les types publics. Il gère System.Threading et System.Threading.Tasks .

Le .NET Framework 4 propose des API au niveau du langage et du framework pour les développeurs qui souhaitent écrire du code parallèle. Avec l'aide de TPL, la programmation asynchrone permet aux programmes de s'exécuter sans bloquer le thread principal.

Voici un exemple de programmation asynchrone avec TPL :

Tâche<chaîne> tâche = Task.Factory.StartNew<chaîne>(() => {

retourner "résultat" ;

});

résultat de chaîne = tâche.Résultat ;

Tâche asynchrone MaMéthode() {

résultat de la chaîne = attendre la tâche ;

}

Consultez noscours de technologie gratuits pour vous démarquer de la concurrence.

Bonnes pratiques pour le multithreading en C#

Le multithreading peut être un gain de temps en termes de performances et de multitâche. Pour en savoir plus sur le fonctionnement du multithreading, vous pouvez opter pour un Master of Science in Computer Science de LJMU .

Voici quelques bonnes pratiques pour aider les utilisateurs à gagner du temps et à enregistrer la plus grande efficacité.

• Utiliser des collections thread-safe : les collections simultanées de .NET Framework fournissent une version thread-safe de chaque collection, ce qui facilite le fonctionnement efficace du multithreading.Ces collections incluent des listes et des requêtes, ainsi que des dictionnaires.
• Implémenter la synchronisation des threads : les utilisateurs peuvent rapidement implémenter des verrous, des moniteurs et des sémaphores en raison de la nature des outils de thread.
• Utiliser le pooling de threads : le multithreading peut être plus facile et plus efficace pour les systèmes, grâce à la grande majorité du pooling de threads effectué par les utilisateurs.En même temps, les utilisateurs peuvent l'utiliser pour créer automatiquement des fils de discussion.
• Utiliser le stockage local des threads : lors de la pratique du multithreading, assurez l'accès à une ressource particulière en optimisant le stockage local des threads et en offrant l'accès à plusieurs threads.
• Évitez de partager des états mutables : les états mutables partagés n'entraîneront que des bogues et des conditions de concurrence, ce qui peut être délicat.Assurez-vous d'éviter les états mutables à tout prix.
• Utiliser un modèle asynchrone : les méthodes asynchrones vous aident à implémenter plusieurs tâches en parallèle sans les redémarrer ni les laisser dans la file d'attente.
• Éviter les interblocages : des interblocages peuvent survenir lors de l'exécution de programmes utilisant le multithreading.Lors de l'écriture d'un programme, essayez d'exécuter un thread uniquement après un autre, en évitant les blocages.
• Utiliser des jetons d'annulation : les jetons d'annulation permettent de terminer les threads sans problème et d'éviter les interblocages.

Explorez nos cours populaires de génie logiciel

Conclusion

Le multithreading en C # reste un concept essentiel avec son modèle à haute efficacité au travail. Il offre aux programmeurs un moyen flexible de diviser la charge de travail d'un programme en plusieurs tâches exécutées simultanément et indépendamment.

Bien que le multithreading puisse être très bénéfique, il peut entraîner des obstacles potentiels s'il n'est pas mis en œuvre avec soin.

Avec un budget mondial pour les logiciels d'entreprise dépassant 856 milliards de dollars entre 2009 et 2023, le développement de logiciels promet une brillante carrière aux développeurs.

Postulez dès maintenant pour le Bootcamp de développement logiciel Full Stack d'upGrad ! Un cours de développement full stack peut être le tremplin pour les développeurs qui souhaitent libérer leur potentiel en informatique.