Défi .NET de 30 jours - Jour 17 : Qu'est-ce que l'outil de classe verrouillée ?

Le .Net fournit un outil puissant appelé classe « Interlocked » pour toutes les opérations atomiques grâce auquel les développeurs peuvent réduire les conflits et améliorer les performances de l'application.

Introduction

Dans les scénarios d'applications multithread, l'utilisation de techniques de verrouillage traditionnelles peut parfois entraîner des goulots d'étranglement dans les performances des opérations atomiques. Le .Net fournit un outil puissant appelé classe « Interlocked » pour toutes les opérations atomiques grâce auquel les développeurs peuvent réduire les conflits et améliorer les performances de l'application.

Objectifs d'apprentissage

• Problème avec les serrures
• Utiliser des classes verrouillées

Conditions préalables pour les développeurs

• Compréhension de base du langage de programmation C#

Défi .Net de 30 jours

Commencer

Comprendre le problème des serrures

Traditionnellement, pour garantir la sécurité des threads lorsque plusieurs threads accèdent à une ressource partagée, les développeurs utilisent des verrous. Le verrouillage empêche plusieurs threads d'entrer simultanément dans une section critique du code, garantissant ainsi qu'un seul thread à la fois peut modifier la ressource partagée.

 private int _counter; private readonly object _syncRoot = new object(); public void IncrementCounter() { lock (_syncRoot) { _counter++; } }

L'approche susmentionnée introduit un risque de problème de performances potentiel appelé contention dans lequel lorsque plusieurs threads tentent d'accéder au verrou simultanément, ils sont mis en attente, à l'exception de celui qui obtient le verrou avec succès.

La classe verrouillée : une meilleure solution

Le framework .NET propose la classe Interlocked dans le cadre de l'espace de noms System.Threading, conçue pour effectuer efficacement des opérations atomiques. Les opérations atomiques sont indivisibles ; ils se terminent entièrement sans interruption.

 private int _counter; public void IncrementCounter() { Interlocked.Increment(ref _counter); }

Comme la classe Interlocked ne nécessite pas de verrous, elle résout le problème de conflit comme mentionné dans l'approche traditionnelle.

Exemple complet

Ajoutez un nouveau nom de classe IncrementClass et ajoutez l'extrait de code suivant

 public static class IncrementClass { private static int _counter = 0; /// <summary> /// Outputs /// Counter value: 10 /// </summary> public static void TestIncrementCounter() { // Create an array to hold the tasks Task[] tasks = new Task[10]; // Initialize and start tasks for (int i = 0; i < tasks.Length; i++) { tasks[i] = Task.Run(() => IncrementCounter()); } // Wait for all tasks to complete Task.WaitAll(tasks); Console.WriteLine($"Counter value: {_counter}"); } public static void IncrementCounter() { // Safely increment the counter across multiple threads Interlocked.Increment(ref _counter); } }

Appelez depuis la méthode main comme suit :

 #region Day 17: Increment Class IncrementClass.TestIncrementCounter(); #endregion

Sortie de la console :

 Counter value: 10

Code complet sur GitHub

GitHub — ssukhpinder/30DayChallenge.Net

Programmation C#🚀

Merci de faire partie de la communauté C# ! Avant que tu partes:

Suivez-nous : Youtube | X | LinkedIn | Dev.to Visitez nos autres plateformes : GitHub