Controle de concorrência em C#: Semaphore e SemaphoreSlim

Um caso real para o SemaphoreSlim

Imagine o seguinte cenário hipotético. Você precisa buscar todo dia a previsão do tempo de todas as cidades do Brasil, mas o provedor da API permite apenas três acessos simultâneos.

Se você disparar milhares de requisições de uma vez, a API vai recusar a maioria delas. Por outro lado, fazer uma requisição por vez desperdiça tempo.

O SemaphoreSlim resolve exatamente esse meio termo. Com ele, você acessa a API o mais rápido possível, sem passar de três chamadas ao mesmo tempo.

Como usar o SemaphoreSlim passo a passo

Primeiro, criamos a instância do SemaphoreSlim, definindo que o máximo será de três execuções simultâneas.

var semaphore = new SemaphoreSlim(3);

Em seguida, criamos uma lista de tarefas, que vai guardar todas as chamadas em andamento.

var tasks = new List<Task>();

Então, adicionamos as tarefas à lista. Cada tarefa usa o WaitAsync do SemaphoreSlim para aguardar a autorização de execução.

tasks.Add(ProcessForecastAsync(city));

A tarefa termina sempre com Release, dentro do bloco finally. Isso garante que a vaga volte para o semáforo, mesmo em caso de erro.

finally { semaphore.Release(); }

Por último, depois da iteração, usamos o Task.WhenAll, do namespace System.Threading.Tasks, para aguardar a conclusão de todas as tarefas.

await Task.WhenAll(tasks);

Durante a execução, o SemaphoreSlim atua como um portão. As tarefas pedem permissão pelo WaitAsync, e ele garante que no máximo três trabalhem ao mesmo tempo, enquanto as outras esperam a vez.

Exemplo completo com SemaphoreSlim

Juntando as partes, o código fica assim:

var cities = GetCities();
var semaphore = new SemaphoreSlim(3);
using var httpClient = new HttpClient();
var tasks = new List<Task>();

foreach (var city in cities)
{
    tasks.Add(ProcessForecastAsync(city));
}

await Task.WhenAll(tasks);
Console.WriteLine("Forecasts processed.");

async Task ProcessForecastAsync(City city)
{
    // Aguarda uma vaga livre no semáforo
    await semaphore.WaitAsync();
    try
    {
        var url = $"https://api.example.com/forecast/{city.State.ToLower()}/{city.Name.ToLower()}";
        Console.WriteLine($"[START] {city.Name}, {city.State} {DateTime.Now:HH:mm:ss}");

        var response = await httpClient.GetAsync(url);
        response.EnsureSuccessStatusCode();

        var forecast = await response.Content.ReadAsStringAsync();

        Console.WriteLine($"[END] {city.Name}, {city.State} {DateTime.Now:HH:mm:ss}");
    }
    catch (HttpRequestException ex)
    {
        Console.WriteLine($"[ERROR] Failed to fetch {city.Name}: {ex.Message}");
    }
    finally
    {
        // Devolve a vaga, mesmo se ocorrer uma exceção
        semaphore.Release();
    }
}

record City(string Name, string State);

O método ProcessForecastAsync está no mesmo escopo da variável semaphore, por isso consegue acessá-la diretamente. Em outros contextos, talvez você precise passar o semáforo como parâmetro ou registrá-lo na injeção de dependência.

Repare também que todas as tarefas são criadas de uma vez. Contudo, apenas três avançam além do WaitAsync, e as demais ficam aguardando sem bloquear nenhuma thread.

Vale ressaltar que o SemaphoreSlim não é restrito a listas. Na verdade, esse é o grande diferencial dele em relação ao Parallel.ForEachAsync, da Task Parallel Library (TPL), que trabalha sobre coleções.

Tempo limite e cancelamento

O WaitAsync aceita um tempo limite e um CancellationToken. Com o tempo limite, o método retorna false quando não consegue a vaga a tempo.

// Espera no máximo 5 segundos por uma vaga
if (!await semaphore.WaitAsync(TimeSpan.FromSeconds(5), cancellationToken))
{
    Console.WriteLine("No slot available, try again later.");
    return;
}

try
{
    await CallExternalApiAsync(cancellationToken);
}
finally
{
    semaphore.Release();
}

Nesse caso, o Release fica dentro do try que vem depois da espera. Afinal, se a tarefa não conseguiu a vaga, ela não pode devolver uma vaga que nunca recebeu.

Da mesma forma, se o token for cancelado durante a espera, o WaitAsync lança OperationCanceledException. Portanto, mantenha a chamada de espera fora do bloco protegido pelo finally.

SemaphoreSlim como lock assíncrono

A palavra-chave lock do C# não permite await dentro do bloco. Por isso, um SemaphoreSlim com uma única vaga é a solução mais comum para exclusão mútua em código assíncrono.

private static readonly SemaphoreSlim _cacheLock = new(1, 1);

public async Task<Report> GetReportAsync()
{
    await _cacheLock.WaitAsync();
    try
    {
        // Apenas uma tarefa por vez atualiza o cache
        return _cachedReport ??= await BuildReportAsync();
    }
    finally
    {
        _cacheLock.Release();
    }
}

O segundo parâmetro do construtor define a contagem máxima. Assim, se algum código chamar Release a mais, o semáforo lança SemaphoreFullException em vez de abrir uma segunda vaga silenciosamente.

Propriedades úteis

A propriedade CurrentCount informa quantas vagas estão livres no momento. Ela ajuda em logs e diagnósticos, mas não deve guiar decisões, porque o valor pode mudar logo depois da leitura.

Além disso, o SemaphoreSlim implementa IDisposable. Portanto, descarte a instância quando ela não for mais necessária, principalmente se ela foi criada por requisição.

Um caso real para o Semaphore

Imagine que você está criando sua própria plataforma de vídeos, mas o servidor não consegue converter muitos vídeos ao mesmo tempo. Cada vídeo enviado precisa de cinco codificações, em 240p, 360p, 720p, 1080p e 2160p.

Ou seja, cada usuário gera cinco processos de conversão. Além disso, o servidor usa várias Application Pools, então as conversões rodam em processos diferentes.

Nesse caso, você precisa de um semáforo global, que controle todos os processos. A chave para compartilhá-lo é que todos usem o mesmo nome.

var semaphoreGlobalName = @"Global\VideoConversionSemaphore";

O prefixo Global\ coloca o semáforo no namespace global do Windows. Assim, ele fica visível para processos de todas as sessões do servidor.

Criando o Semaphore nomeado

Para criar o semáforo global, você define o número inicial de vagas, o número máximo e o nome. O construtor também devolve um booleano que indica se um semáforo novo foi criado ou se um existente foi reaproveitado.

var semaphore = new Semaphore(initialCount, maximumCount, semaphoreGlobalName, out bool createdNew);

Em seguida, criamos as tarefas de conversão de vídeo. O exemplo repete código de propósito, apenas para ficar ilustrativo, mas vale revisar os princípios SOLID antes de levar algo parecido para produção.

var semaphoreGlobalName = @"Global\VideoConversionSemaphore";

var initialCount = 2;
var maximumCount = 2;

using var semaphore = new Semaphore(initialCount, maximumCount, semaphoreGlobalName, out bool createdNew);

Console.WriteLine(createdNew ? "New global semaphore created." : "Connected to existing semaphore.");

var t240 = Convert240pAsync();
var t360 = Convert360pAsync();
var t720 = Convert720pAsync();
var t1080 = Convert1080pAsync();
var t2160 = Convert2160pAsync();

await Task.WhenAll(t240, t360, t720, t1080, t2160);

Console.WriteLine("All conversions finished.");

Assim como no SemaphoreSlim, usamos o Task.WhenAll para aguardar todas as tarefas. O restante segue a mesma lógica: aguardar a vaga, executar e liberar.

Aguardando e liberando vagas no Semaphore

As tarefas controladas pelo Semaphore usam WaitOne() para aguardar e Release() para liberar. Porém, o WaitOne é síncrono e bloqueia a thread que o chama.

Por isso, é importante envolver o WaitOne em um Task.Run. Isso move a espera para o thread pool, mas não torna a operação verdadeiramente assíncrona, já que uma thread do pool continua bloqueada.

async Task Convert240pAsync()
{
    // Move a espera bloqueante para o thread pool
    await Task.Run(() => semaphore.WaitOne());
    try
    {
        // lógica de conversão 240p
    }
    finally
    {
        semaphore.Release();
    }
}

Nesse código, a thread que libera pode ser diferente da que aguardou. Isso não é problema, porque nenhum dos dois tipos de semáforo exige que a mesma thread faça as duas operações.

Limitações e segurança

Atenção a um ponto de portabilidade. Os semáforos nomeados são um recurso do Windows, e a documentação informa que eles não são suportados em sistemas baseados em Unix.

Também existe um risco de segurança. Como o nome é visível em todo o sistema, outro processo pode usar o mesmo nome e ocupar as vagas, inclusive de forma maliciosa.

Para reduzir esse risco, a Microsoft recomenda proteger o semáforo com controle de acesso, usando SemaphoreSecurity. Ainda assim, isso não evita colisões acidentais de nome, então escolha nomes bem específicos.