Desafío .NET de 30 días - Día 17: ¿Qué es la herramienta de clase entrelazada?

.Net proporciona una poderosa herramienta llamada clase "Interlocked" para todas las operaciones atómicas a través de la cual los desarrolladores pueden reducir la contención y mejorar el rendimiento de la aplicación.

Introducción

En escenarios de aplicaciones de subprocesos múltiples, el uso de técnicas de bloqueo tradicionales a veces puede causar cuellos de botella en el rendimiento de las operaciones atómicas. .Net proporciona una poderosa herramienta llamada clase "Interlocked" para todas las operaciones atómicas a través de la cual los desarrolladores pueden reducir la contención y mejorar el rendimiento de la aplicación.

Objetivos de aprendizaje

• problema con las cerraduras
• Usando clases entrelazadas

Requisitos previos para desarrolladores

• Conocimientos básicos del lenguaje de programación C#.

Desafío .Net de 30 días

Empezando

Comprender el problema de las cerraduras

Tradicionalmente, para garantizar la seguridad de los subprocesos cuando varios subprocesos acceden a un recurso compartido, los desarrolladores utilizan bloqueos. El bloqueo evita que varios subprocesos ingresen a una sección crítica de código simultáneamente, garantizando así que solo un subproceso a la vez pueda modificar el recurso compartido.

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

El enfoque antes mencionado introduce un riesgo de posible problema de rendimiento llamado contención en el que cuando varios subprocesos intentan acceder al bloqueo simultáneamente, se ponen en espera, excepto el que obtiene el bloqueo con éxito.

La clase entrelazada: una mejor manera

El marco .NET ofrece la clase Interlocked como parte del espacio de nombres System.Threading, diseñado para realizar operaciones atómicas de manera eficiente. Las operaciones atómicas son indivisibles; se completan completamente sin interrupción.

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

Como la clase Interlocked no requiere bloqueos, resuelve el problema de contención como se menciona en el enfoque tradicional.

Ejemplo completo

Agregue un nuevo nombre de clase IncrementClass y agregue el siguiente fragmento de código

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

Llame desde el método principal de la siguiente manera:

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

Salida de consola:

 Counter value: 10

Código completo en GitHub

GitHub — ssukhpinder/30DayChallenge.Net

Programación C#🚀

¡Gracias por ser parte de la comunidad C#! Antes de que te vayas:

Síguenos: Youtube | X | LinkedIn | Dev.to Visita nuestras otras plataformas: GitHub