C# – Controle suas tasks usando o SemaphoreSlim -Dica

Neste artigo, veremos como executar tarefas em paralelo e aprenderemos a usar a classe SemaphoreSlim para ajudar a controlar a execução de nossas tarefas.

É muito comum hoje em dia criarmos métodos assíncronos que recebem varias requisições ao mesmo tempo, mas imagine uma situação onde você teria que garantir que somente uma task executasse dentro do seu método por vez?

E que outra task só entraria depois que a primeira terminasse o processamento?
Ou ainda permitir que lotes de tasks entrassem em seu método por vez?

Pois bem em cenários onde ser torna necessário ter controle sobre a execução de suas tasks podemos usar a classe SemaphoreSlim do .NET, basicamente essa classe limita o número de threads que podem acessar um recurso compartilhado simultaneamente.

Para demonstrar vamos criar um código bem simples que simula a chamada a uma API.

Abaixo o código da chamada principal, vamos executar o mesmo código sem o objeto Semaphore e com o objeto Semaphore para compararmos depois a diferença:

Código principal da classe
Código sem o objeto Semaphore

No método InitProcess simplesmente estamos criando uma lista de tasks e dentro de um for adicionando 20 tarefas para serem executadas. Usamos o Task.WaitAll na linha 10 para executar as tarefas que neste caso serão executadas simultaneamente.

Depois de executar podemos observar pelo log gerado que o processamento demorou 1 segundo e 557 milissegundos:

execução do código sem o Semaphore

Agora vamos executar o mesmo código utilizando o objeto Semaphore:

Código com o objeto Semaphore

No método InitProcess inserimos uma variável do tipo SemaphoreSlim definindo ali o número 1 especificando que somente 1 request/entrada poderá ser executada simultaneamente na linha 3 do código.

Este objeto tem uma sobrecarga que permite a inclusão da quantidade de requests que pode ser feitas simultaneamente (InitialCount) e também o número máximo de requests que podem ser executadas simultaneamente(MaxCount).

Dentro do método ProcessWithSemaphore usamos dois métodos do objeto Semaphore: WaitAsync() e Release(), eles são responsáveis por fazer a execução, aguardar e liberar a posição para o semáforo.

Rodando o projeto novamente vamos ver como saída:

execução do código com o Semaphore

O processo demorou mais de 26 segundos para ser executado porque definimos pelo Semaphore que somente 1 solicitação poderia ser executada por vez. O processo foi mais lento que o primeiro exemplo mas foi executado de maneira “controlada“.

Este código inteiro pode ser visto aqui no meu github.

Referencias

Microsoft Documentation

Aprendendo mais uma!!!!!

É isso ae, aprendendo sempre! se curtiu ou ajudou comenta para fortalecer! obrigado e até a próxima.

Deixe um comentário

O seu endereço de e-mail não será publicado.