Concorrência - Aula Prática

Exemplo 1 — O problema do saldo

O mesmo cenário da teoria: saldo de R$ 1000 e dois saques ao mesmo tempo (R$ 600 e R$ 500). O Thread.Sleep apenas simula um pequeno atraso entre ler o saldo e gravar o novo valor — é nesse intervalo que o problema acontece.

decimal saldo = 1000;

void Sacar(decimal valor)
{
    decimal lido = saldo;        // 1. ler saldo
    Thread.Sleep(100);           // simula um pequeno atraso

    if (lido >= valor)           // 2. verificar
    {
        saldo = lido - valor;    // 3. calcular e 4. gravar
        Console.WriteLine($"Saque de R$ {valor} APROVADO");
    }
    else
    {
        Console.WriteLine($"Saque de R$ {valor} NEGADO");
    }
}

Task t1 = Task.Run(() => Sacar(600));
Task t2 = Task.Run(() => Sacar(500));
await Task.WhenAll(t1, t2);

Console.WriteLine($"Saldo final: R$ {saldo}");

Desafios:

• Rode o código. Os dois saques foram aprovados? Qual o saldo final? Faz sentido?
• Rode mais algumas vezes. O saldo final é sempre o mesmo?

Pense e responda:

• No código, o saque de R$ 600 aparece antes do de R$ 500, e os dois têm o mesmo Thread.Sleep(100). Mesmo assim, a cada execução um saque diferente pode terminar primeiro. Por quê? (Dica: quem decide qual thread roda primeiro é o sistema operacional, não a ordem das linhas no código.)

Exemplo 2 — Corrigindo com lock

Ler, verificar, calcular e gravar formam uma região crítica: precisam acontecer como uma coisa só. O lock garante que apenas uma operação por vez entre nesse bloco — a outra espera.

decimal saldo = 1000;
object bloqueio = new object();

void Sacar(decimal valor)
{
    lock (bloqueio)
    {
        decimal lido = saldo;
        Thread.Sleep(100);

        if (lido >= valor)
        {
            saldo = lido - valor;
            Console.WriteLine($"Saque de R$ {valor} APROVADO");
        }
        else
        {
            Console.WriteLine($"Saque de R$ {valor} NEGADO");
        }
    }
}

Task t1 = Task.Run(() => Sacar(600));
Task t2 = Task.Run(() => Sacar(500));
await Task.WhenAll(t1, t2);

Console.WriteLine($"Saldo final: R$ {saldo}");

Desafios:

• Rode várias vezes. Agora quantos saques são aprovados? O saldo final está correto?
• Mova o lock para proteger apenas a linha saldo = lido - valor;. O problema volta? Por quê?

Pense e responda:

• Rodando várias vezes, às vezes é aprovado o saque de R$ 600 e às vezes o de R$ 500. Isso é um erro? O lock garante a consistência (nunca aprova os dois) ou também garante a ordem em que os saques acontecem?

Exemplo 3 — Limitando relatórios com SemaphoreSlim

Agora o problema é outro: 10 relatórios pesados chegam juntos, mas o servidor aguenta no máximo 3 ao mesmo tempo. O Task.Delay(1000) simula 1 segundo de processamento de cada relatório.

using System.Diagnostics;

SemaphoreSlim limite = new SemaphoreSlim(3);   // 3 permissões
Stopwatch relogio = Stopwatch.StartNew();

async Task GerarRelatorioAsync(int numero)
{
    await limite.WaitAsync();                  // pega uma permissão (ou espera)
    try
    {
        Console.WriteLine($"[{relogio.Elapsed.TotalSeconds:F1}s] Relatório {numero} começou");
        await Task.Delay(1000);                // simula o processamento
        Console.WriteLine($"[{relogio.Elapsed.TotalSeconds:F1}s] Relatório {numero} terminou");
    }
    finally
    {
        limite.Release();                      // devolve a permissão
    }
}

List<Task> tarefas = new List<Task>();
for (int i = 1; i <= 10; i++)
{
    tarefas.Add(GerarRelatorioAsync(i));
}
await Task.WhenAll(tarefas);

Console.WriteLine($"Tempo total: {relogio.Elapsed.TotalSeconds:F1}s");

Desafios:

• Rode e observe os horários: quantos relatórios começam juntos? Qual o tempo total?
• Troque o limite para 1 e depois para 10. O que acontece com o tempo total em cada caso?
• Comente a linha limite.Release(); e rode. O que acontece? Por que o Release fica dentro do finally?