System.Threading.Timer C # içinde çalışmıyor gibi görünüyor. Her 3 saniyede çok hızlı çalışır

Bir zamanlayıcı nesnem var. Her dakika çalışmasını istiyorum. Özellikle, bir OnCallBackyöntem çalıştırmalı ve bir OnCallBackyöntem çalışırken devre dışı kalmalıdır . Bir OnCallBackyöntem bittiğinde, (a OnCallBack) bir zamanlayıcıyı yeniden başlatır.

İşte şu anda sahip olduğum şey:

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
}

Ancak, çalışmıyor gibi görünüyor. Her 3 saniyede çok hızlı çalışır. Bir dönem artırsa bile (1000 * 10). Görmezden geliyor gibi görünüyor1000 * 10

Neyi yanlış yaptım?

Bu, System.Threading.Timer'ın doğru kullanımı değildir. Zamanlayıcıyı örneklediğinizde, hemen hemen her zaman aşağıdakileri yapmalısınız:

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

Bu, zamanlayıcıya aralık sona erdiğinde yalnızca bir kez işlem yapması talimatını verecektir. Ardından Geri Arama işlevinizde zamanlayıcıyı daha önce değil, iş tamamlandığında değiştirirsiniz. Misal:

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

Dolayısıyla, eşzamanlılık olmadığı için kilitleme mekanizmalarına gerek yoktur. Zamanlayıcı, sonraki aramayı + uzun süren işlemin süresini geçtikten sonra başlatır.

Zamanlayıcınızı tam olarak N milisaniyede çalıştırmanız gerekiyorsa, Kronometre'yi kullanarak uzun süren işlemin süresini ölçmenizi ve ardından uygun şekilde Değiştir yöntemini çağırmanızı öneririm:

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

NET yapan ve Jeffrey Richter'in kitabını okumamış CLR'yi kullanan herkesi şiddetle tavsiye ediyorum - C # aracılığıyla CLR , okuması mümkün olan en kısa sürede. Zamanlayıcılar ve iş parçacığı havuzları burada büyük ayrıntılarla açıklanmıştır.

Zamanlayıcıyı durdurmak gerekli değildir , bu gönderiden güzel çözümü görün :

"Zamanlayıcının geri arama yöntemini çalıştırmaya devam etmesine izin verebilir, ancak tekrar girişli olmayan kodunuzu bir Monitor. TryEnter / Exit'e sarabilirsiniz. Bu durumda zamanlayıcıyı durdurmanıza / yeniden başlatmanıza gerek yoktur; örtüşen çağrılar kilidi almayacak ve hemen geri dönmeyecektir."

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

Kullanmak System.Threading.Timerzorunlu mu?

Değilse System.Timers.Timer, kullanışlı Start()ve Stop()yöntemlere sahiptir (ve AutoResetfalse olarak ayarlayabileceğiniz bir özellik, böylece Stop()gerekli değildir ve Start()çalıştırdıktan sonra yalnızca çağırırsınız ).

Sadece yapardım:

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
  }

Ayrıca periyodik olanı kendiniz kontrol etmeye çalıştığınız için dönem parametresini yok sayın.

Parametre 0için belirlemeye devam ettiğiniz için orijinal kodunuz olabildiğince hızlı çalışıyor dueTime. Kimden Timer.Change:

DueTime sıfır (0) ise, geri arama yöntemi hemen çağrılır.

 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)

içinde biraz döngü ipliği kullanmayı seviyorsanız ...

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.