System.Threading.Timer em C # parece não estar funcionando. Corre muito rápido a cada 3 segundos

Eu tenho um objeto temporizador. Eu quero que seja executado a cada minuto. Especificamente, ele deve executar um OnCallBackmétodo e ficar inativo enquanto um OnCallBackmétodo está sendo executado. Quando um OnCallBackmétodo termina, ele (a OnCallBack) reinicia um cronômetro.

Aqui está o que tenho agora:

private static Timer timer;

private static void Main()
{
    timer = new Timer(_ => OnCallBack(), null, 0, 1000 * 10); //every 10 seconds
    Console.ReadLine();
}

private static void OnCallBack()
{
    timer.Change(Timeout.Infinite, Timeout.Infinite); //stops the timer
    Thread.Sleep(3000); //doing some long operation
    timer.Change(0, 1000 * 10);  //restarts the timer
}

No entanto, parece não estar funcionando. Corre muito rápido a cada 3 segundos. Mesmo quando se levanta um período (1000 * 10). Parece que fecha os olhos para1000 * 10

O que eu fiz errado?

Este não é o uso correto do System.Threading.Timer. Ao instanciar o Timer, você deve quase sempre fazer o seguinte:

_timer = new Timer( Callback, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite );

Isso instruirá o cronômetro a marcar apenas uma vez quando o intervalo tiver decorrido. Em seguida, em sua função de retorno de chamada, você altera o cronômetro quando o trabalho é concluído, não antes. Exemplo:

private void Callback( Object state )
{
    // Long running operation
   _timer.Change( TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite );
}

Portanto, não há necessidade de mecanismos de bloqueio porque não há concorrência. O cronômetro irá disparar o próximo retorno de chamada após o próximo intervalo ter decorrido + o tempo da operação de longa duração.

Se você precisa executar seu cronômetro em exatamente N milissegundos, sugiro que você meça o tempo da operação de longa duração usando o cronômetro e chame o método Change apropriadamente:

private void Callback( Object state )
{
   Stopwatch watch = new Stopwatch();

   watch.Start();
   // Long running operation

   _timer.Change( Math.Max( 0, TIME_INTERVAL_IN_MILLISECONDS - watch.ElapsedMilliseconds ), Timeout.Infinite );
}

Eu encorajo fortemente qualquer um que esteja usando .NET e esteja usando o CLR que não leu o livro de Jeffrey Richter - CLR via C # , para ler o mais rápido possível. Timers e pools de thread são explicados em detalhes aqui.

Não é necessário parar o cronômetro, veja uma boa solução neste post :

"Você poderia deixar o cronômetro continuar disparando o método de retorno de chamada, mas envolver seu código não reentrante em um Monitor.TenteEntrar / Sair. Não há necessidade de parar / reiniciar o cronômetro nesse caso; chamadas sobrepostas não obterão o bloqueio e retornarão imediatamente."

private void CreatorLoop(object state) 
 {
   if (Monitor.TryEnter(lockObject))
   {
     try
     {
       // Work here
     }
     finally
     {
       Monitor.Exit(lockObject);
     }
   }
 }

Está usando System.Threading.Timerobrigatório?

Se não, System.Timers.Timertem métodos Start()e úteis Stop()(e uma AutoResetpropriedade que você pode definir como falsa, de forma que o Stop()não seja necessário e você simplesmente chama Start()após a execução).

Eu apenas faria:

private static Timer timer;
 private static void Main()
 {
   timer = new Timer(_ => OnCallBack(), null, 1000 * 10,Timeout.Infinite); //in 10 seconds
   Console.ReadLine();
 }

  private static void OnCallBack()
  {
    timer.Dispose();
    Thread.Sleep(3000); //doing some long operation
    timer = new Timer(_ => OnCallBack(), null, 1000 * 10,Timeout.Infinite); //in 10 seconds
  }

E ignore o parâmetro de período, já que você está tentando controlar o período por conta própria.

Seu código original está sendo executado o mais rápido possível, já que você continua especificando 0o dueTimeparâmetro. De Timer.Change:

Se dueTime for zero (0), o método de retorno de chamada será invocado imediatamente.

 var span = TimeSpan.FromMinutes(2);
 var t = Task.Factory.StartNew(async delegate / () =>
   {
        this.SomeAsync();
        await Task.Delay(span, source.Token);
  }, source.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);

source.Cancel(true/or not);

// or use ThreadPool(whit defaul options thread) like this
Task.Start(()=>{...}), source.Token)

se você quiser, use algum fio de loop dentro ...

public async void RunForestRun(CancellationToken token)
{
  var t = await Task.Factory.StartNew(async delegate
   {
       while (true)
       {
           await Task.Delay(TimeSpan.FromSeconds(1), token)
                 .ContinueWith(task => { Console.WriteLine("End delay"); });
           this.PrintConsole(1);
        }
    }, token) // drop thread options to default values;
}

// And somewhere there
source.Cancel();
//or
token.ThrowIfCancellationRequested(); // try/ catch block requred.