System.Threading.Timer in C # sembra non funzionare. Funziona molto velocemente ogni 3 secondi

Ho un oggetto timer. Voglio che venga eseguito ogni minuto. In particolare, dovrebbe eseguire un OnCallBackmetodo e diventare inattivo mentre un OnCallBackmetodo è in esecuzione. Una volta che un OnCallBackmetodo finisce, (a OnCallBack) riavvia un timer.

Ecco cosa ho adesso:

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
}

Tuttavia, sembra che non funzioni. Funziona molto velocemente ogni 3 secondi. Anche quando si alza un punto (1000 * 10). Sembra che chiuda un occhio1000 * 10

Cos'ho fatto di sbagliato?

Questo non è l'utilizzo corretto di System.Threading.Timer. Quando installi il timer, dovresti quasi sempre fare quanto segue:

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

Questo indicherà al timer di spuntare solo una volta quando l'intervallo è trascorso. Quindi nella funzione di richiamata si modifica il timer una volta che il lavoro è stato completato, non prima. Esempio:

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

Quindi non c'è bisogno di meccanismi di blocco perché non c'è concorrenza. Il timer attiverà la richiamata successiva allo scadere dell'intervallo successivo + il tempo dell'operazione di lunga durata.

Se devi far funzionare il tuo timer esattamente a N millisecondi, allora ti suggerisco di misurare il tempo dell'operazione di lunga durata usando Stopwatch e quindi chiamare il metodo Change in modo appropriato:

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 );
}

Ho fortemente Incoraggio chiunque fare .NET e sta utilizzando il CLR che non ha letto il libro di Jeffrey Richter - CLR via C # , per leggere è il più presto possibile. I timer e i pool di thread sono spiegati in grande dettaglio qui.

Non è necessario fermare il timer, vedi bella soluzione da questo post :

"Potresti lasciare che il timer continui ad attivare il metodo di callback ma racchiudi il tuo codice non rientrante in un Monitor.TryEnter / Exit. In tal caso non è necessario arrestare / riavviare il timer; le chiamate sovrapposte non acquisiranno il blocco e torneranno immediatamente."

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

L'uso è System.Threading.Timerobbligatorio?

In caso contrario, System.Timers.Timerha a portata di mano Start()e Stop()metodi (e una AutoResetproprietà che puoi impostare su false, in modo che Stop()non sia necessario e tu chiami semplicemente Start()dopo l'esecuzione).

Vorrei solo fare:

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 ignora il parametro period, poiché stai tentando di controllare tu stesso la periodica.

Il codice originale viene eseguito il più velocemente possibile, poiché continui a specificare 0il dueTimeparametro. Da Timer.Change:

Se dueTime è zero (0), il metodo di callback viene richiamato immediatamente.

 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 ti piace usare un filo ad anello all'interno ...

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.