30-Tage-.NET-Challenge – Tag 17: Was ist das Interlocked Class Tool?

.Net bietet für alle atomaren Operationen ein leistungsstarkes Tool namens „Interlocked“-Klasse, mit dem Entwickler Konflikte reduzieren und die Leistung der Anwendung verbessern können.

Einführung

In Anwendungsszenarien mit mehreren Threads kann die Verwendung herkömmlicher Sperrtechniken manchmal zu Leistungsengpässen bei atomaren Operationen führen. .Net bietet ein leistungsstarkes Tool namens „Interlocked“-Klasse für alle atomaren Operationen, mit dem Entwickler Konflikte reduzieren und die Leistung der Anwendung verbessern können.

Lernziele

• Problem mit Schlössern
• Verwenden von Interlocked-Klassen

Voraussetzungen für Entwickler

• Grundlegende Kenntnisse der Programmiersprache C#

30 Tage .Net Challenge

Erste Schritte

Das Problem mit Schlössern verstehen

Um die Thread-Sicherheit zu gewährleisten, wenn mehrere Threads auf eine gemeinsam genutzte Ressource zugreifen, verwenden Entwickler traditionell Sperren. Durch Sperren wird verhindert, dass mehrere Threads gleichzeitig auf einen kritischen Codeabschnitt zugreifen. Auf diese Weise wird sichergestellt, dass immer nur ein Thread die gemeinsam genutzte Ressource ändern kann.

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

Der oben genannte Ansatz birgt das Risiko potenzieller Leistungsprobleme, sogenannter Konflikte: Wenn mehrere Threads gleichzeitig versuchen, auf die Sperre zuzugreifen, werden sie angehalten, mit Ausnahme des Threads, der die Sperre erfolgreich erhält.

Die Interlocked-Klasse: Ein besserer Weg

Das .NET-Framework bietet die Interlocked-Klasse als Teil des System.Threading-Namespace an, der für die effiziente Ausführung atomarer Operationen konzipiert ist. Atomare Operationen sind unteilbar; sie werden vollständig und ohne Unterbrechung ausgeführt.

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

Da die Interlocked-Klasse keine Sperren erfordert, löst sie das im herkömmlichen Ansatz erwähnte Konfliktproblem.

Vollständiges Beispiel

Fügen Sie einen neuen Klassennamen IncrementClass hinzu und fügen Sie den folgenden Codeausschnitt hinzu

 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); } }

Rufen Sie die Hauptmethode wie folgt auf:

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

Konsolenausgabe:

 Counter value: 10

Vollständiger Code auf GitHub

GitHub – ssukhpinder/30DayChallenge.Net

C#-Programmierung🚀

Vielen Dank, dass Sie Teil der C#-Community sind! Bevor Sie gehen:

Folgen Sie uns: Youtube | X | LinkedIn | Dev.to Besuchen Sie unsere anderen Plattformen: GitHub