System.Threading.Timer in C # scheint nicht zu funktionieren. Es läuft alle 3 Sekunden sehr schnell

Ich habe ein Timer-Objekt. Ich möchte, dass es jede Minute ausgeführt wird. Insbesondere sollte es eine OnCallBackMethode ausführen und wird inaktiv, während eine OnCallBackMethode ausgeführt wird. Sobald eine OnCallBackMethode beendet ist, OnCallBackstartet sie (a ) einen Timer neu.

Folgendes habe ich gerade:

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
}

Es scheint jedoch nicht zu funktionieren. Es läuft alle 3 Sekunden sehr schnell. Auch wenn Sie einen Zeitraum erhöhen (1000 * 10). Es scheint, als würde es ein Auge zudrücken1000 * 10

Was habe ich falsch gemacht?

Dies ist nicht die korrekte Verwendung des System.Threading.Timer. Wenn Sie den Timer instanziieren, sollten Sie fast immer Folgendes tun:

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

Dadurch wird der Timer angewiesen, nach Ablauf des Intervalls nur einmal zu ticken. Dann ändern Sie in Ihrer Rückruffunktion den Timer, sobald die Arbeit abgeschlossen ist, nicht vorher. Beispiel:

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

Daher sind keine Sperrmechanismen erforderlich, da keine Parallelität besteht. Der Timer löst den nächsten Rückruf nach Ablauf des nächsten Intervalls + der Zeit des lang laufenden Vorgangs aus.

Wenn Sie Ihren Timer mit genau N Millisekunden ausführen müssen, empfehlen wir Ihnen, die Zeit des Langzeitbetriebs mit der Stoppuhr zu messen und dann die Änderungsmethode entsprechend aufzurufen:

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

Ich stark fördern .NET jemand tun , und wird unter Verwendung der CLR , die nicht Jeffrey Richters Buch gelesen hat - CLR via C # , zu lesen ist , so bald wie möglich. Timer und Thread-Pools werden dort ausführlich erklärt.

Es ist nicht notwendig, den Timer anzuhalten, siehe nette Lösung aus diesem Beitrag :

"Sie können den Timer weiterhin die Rückrufmethode auslösen lassen, aber Ihren nicht wiedereintretenden Code in einen Monitor einbinden. TryEnter / Exit. In diesem Fall muss der Timer nicht gestoppt / neu gestartet werden. Überlappende Anrufe erhalten die Sperre nicht und kehren nicht sofort zurück."

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

Ist die Verwendung System.Threading.Timerobligatorisch?

Wenn nicht, System.Timers.Timerhat handliche Start()und Stop()Methoden (und eine AutoResetEigenschaft, die Sie auf false setzen können, so dass die Stop()nicht benötigt wird und Sie einfach Start()nach der Ausführung aufrufen ).

Ich würde einfach tun:

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
  }

Ignorieren Sie den Parameter period, da Sie versuchen, die Periodizität selbst zu steuern.

Ihr ursprünglicher Code wird so schnell wie möglich ausgeführt, da Sie immer wieder 0den dueTimeParameter angeben. Von Timer.Change:

Wenn dueTime Null (0) ist, wird die Rückrufmethode sofort aufgerufen.

 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)

Wenn du magst, benutze einen Schleifenfaden im Inneren ...

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.