Desafio .NET de 30 dias - Dia 17: O que é a ferramenta Interlocked Class?

O .Net fornece uma ferramenta poderosa chamada classe “Interlocked” para todas as operações atômicas por meio da qual os desenvolvedores podem reduzir a contenção e melhorar o desempenho do aplicativo.

Introdução

Em cenários de aplicativos multithread, o uso de técnicas de bloqueio tradicionais pode, às vezes, causar gargalos de desempenho para operações atômicas. O .Net fornece uma ferramenta poderosa chamada classe “Interlocked” para todas as operações atômicas por meio da qual os desenvolvedores podem reduzir a contenção e melhorar o desempenho do aplicativo.

objetivos de aprendizado

• Problema com fechaduras
• Usando classes interligadas

Pré-requisitos para desenvolvedores

• Compreensão básica da linguagem de programação C#

Desafio .Net de 30 dias

Começando

Compreendendo o problema dos bloqueios

Tradicionalmente, para garantir a segurança do thread quando vários threads acessam um recurso compartilhado, os desenvolvedores usam bloqueios. O bloqueio evita que vários threads entrem simultaneamente em uma seção crítica do código, garantindo assim que apenas um thread por vez possa modificar o recurso compartilhado.

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

A abordagem mencionada acima introduz um risco de possível problema de desempenho chamado contenção, em que quando vários threads tentam acessar o bloqueio simultaneamente, eles são colocados em espera, exceto aquele que obtém o bloqueio com sucesso.

A classe interligada: uma maneira melhor

A estrutura .NET oferece a classe Interlocked como parte do namespace System.Threading, projetada para executar operações atômicas com eficiência. As operações atômicas são indivisíveis; eles são concluídos inteiramente sem interrupção.

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

Como a classe Interlocked não necessita de bloqueios, ela resolve o problema de contenção mencionado na abordagem tradicional.

Exemplo completo

Adicione um novo nome de classe IncrementClass e adicione o seguinte trecho 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); } }

Chame do método principal da seguinte maneira:

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

Saída do console:

 Counter value: 10

Código completo no GitHub

GitHub – ssukhpinder/30DayChallenge.Net

Programação C#🚀

Obrigado por fazer parte da comunidade C#! Antes que partas:

Siga-nos: Youtube | X | LinkedIn | Dev.to Visite nossas outras plataformas: GitHub