Paralelismo - Episódio 29 (Copy)

Episódio 29 - Tarefa longa, ciclo curto: reaproveitando execução em ambiente monitorado

Imagine que você tenha uma aplicação que precisa executar tarefas recorrentes:

Verificar novas mensagens a cada 10 segundos
Checar atualizações em arquivos remotos
Monitorar sensores conectados

Você pode até pensar em usar TTimer, mas logo percebe que:

Timers em Delphi são dependentes da thread principal
Bloqueios podem atrasar a execução ou causar travamentos
O controle de ciclo de vida é frágil

Chegou a hora de combinar dois mundos: thread segura + execução cíclica.

O que queremos?

Que a tarefa não trave a interface
Que o ciclo seja controlado de forma clara
Que erros sejam capturados, mas a tarefa continue
Que possamos interromper quando quiser

A solução? Adaptar o TSafeThread para um modo cíclico, com pausa entre as execuções.

Exemplo

procedure StartCycle;
var
  Params: ISafeThreadParams;
begin
  Params := TSafeThreadParams.New
    .SetOnExecute(
      procedure(Context: TThreadContext)
      var
        I: Integer;
      begin
        I := 0;
        while not Params.CancelRequested do
        begin
          Inc(I);
          TThread.Synchronize(nil,
            procedure
            begin
              Memo1.Lines.Add(Format('Execução %d', [I]));
            end);

          // Simula alguma tarefa
          Sleep(500);

          // Pausa entre ciclos
          for var T := 1 to 10 do
          begin
            if Params.CancelRequested then
              Break;
            Sleep(100);
          end;
        end;
      end)
    .SetOnCancel(
      procedure(Context: TThreadContext)
      begin
        ShowMessage('Ciclo interrompido');
      end)
    .SetThreadName('ThreadCiclica');

  TSafeThread.ExecuteThread(Params);
end;

Por que isso é poderoso?

Você controla o intervalo com precisão
Pode implementar tolerância a falhas: se uma execução falhar, a próxima ainda ocorre
A UI continua responsiva, mesmo com centenas de ciclos
Pode fazer log, estatísticas, retry, etc.

E mais: como você pode cancelar ou substituir o Params, pode integrar isso com comandos JSON externos, como vimos em outros episódios.

Dica extra

Quer monitorar algo continuamente, mas permitir que o usuário mude as regras? Junte:

TSafeThread cíclica
Comando JSON que altera o comportamento no meio da execução
Monitoramento externo do ciclo (via status, log, UI)

Você acaba de criar o seu próprio runtime engine, responsivo e autogerenciado.

No próximo episódio, vamos mostrar como integrar esse mecanismo de execução cíclica com uma interface visual de diagnóstico e monitoramento, com logs, botões de controle e feedback em tempo real.

A thread não é mais uma sombra invisível. Ela é parte viva da experiência do seu usuário.