Paralelismo - Episódio 25 (Copy)

Episódio 25 - Retentativas Inteligentes: Backoff Exponencial no Controle das Execuções

Nem sempre tudo dá certo na primeira tentativa. Um servidor pode estar fora do ar, uma conexão pode oscilar, um timeout pode acontecer. Em situações assim, a pior escolha é repetir a tentativa imediatamente, sem critério — isso só agrava o problema.

E se pudéssemos implementar um mecanismo que tenta novamente de forma progressiva, dando tempo para que o serviço se recupere, e sem forçar o sistema com requisições consecutivas? Bem-vindo ao Backoff Exponencial.

🔁 O que é Backoff Exponencial?

É uma técnica de retentativa progressiva onde, a cada nova falha, o tempo de espera entre as tentativas aumenta exponencialmente.

• 1ª tentativa falhou → esperar 1 segundo
• 2ª falha → esperar 2 segundos
• 3ª falha → esperar 4 segundos
• 4ª falha → esperar 8 segundos
• … até um limite configurável

Esse padrão é utilizado amplamente em sistemas distribuídos, APIs e bibliotecas de redes, justamente por reduzir a sobrecarga em serviços instáveis ou congestionados.

🚀 Aplicando ao TSafeThread

O TSafeThread pode executar qualquer lógica dentro do SetOnExecute, e com isso é possível adicionar lógica de retentativa com backoff exponencial. Por exemplo:

Params := TSafeThreadParams.New
  .SetOnExecute(
    procedure(Context: TThreadContext)
    var
      RetryCount: Integer;
      Delay: Integer;
    begin
      RetryCount := 0;
      Delay := 1000; // 1 segundo

      while RetryCount < 5 do
      begin
        try
          // Executa tarefa (ex: requisição HTTP)
          if ExecutarRequisicao then
            Break;
        except
          on E: Exception do
          begin
            Inc(RetryCount);
            TThread.Sleep(Delay);
            Delay := Delay * 2; // backoff exponencial
          end;
        end;
      end;
    end)

Esse exemplo faz até 5 tentativas, dobrando o tempo de espera a cada erro.

💡 Dicas práticas:

• Sempre defina um número máximo de tentativas, para evitar loops infinitos.
• Use TThread.Sleep apenas em tarefas assíncronas (nunca na UI thread).
• Combine com OnError e OnCancel para rastrear tentativas e desistências.
• Se necessário, armazene o número de falhas em cache persistente (veja Episódio 24).

🧠 Reflexão:

Retentar com estratégia é sinal de inteligência do sistema. Não é sobre insistir, mas saber quando e como insistir.

No próximo episódio, vamos unir várias ideias anteriores para criar uma engine de execução robusta com múltiplos controles: timeout, retentativa, fallback e eventos em tempo real.

Essa é a base de sistemas resilientes — e você já tem as peças para construir o seu.