System.Threading.Timer w C # wydaje się nie działać. Działa bardzo szybko co 3 sekundy

Mam obiekt zegarowy. Chcę, żeby było uruchamiane co minutę. W szczególności powinien uruchamiać OnCallBackmetodę i stać się nieaktywny, gdy OnCallBackmetoda jest uruchomiona. Po OnCallBackzakończeniu metody (a OnCallBack) restartuje licznik czasu.

Oto, co mam teraz:

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
}

Jednak wydaje się, że nie działa. Działa bardzo szybko co 3 sekundy. Nawet jeśli podniesiesz kropkę (1000 * 10). Wygląda na to, że przymyka oko1000 * 10

Co zrobiłem źle?

To nie jest prawidłowe użycie pliku System.Threading.Timer. Podczas tworzenia instancji Timera prawie zawsze należy wykonać następujące czynności:

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

To poinstruuje timer, aby tykał tylko raz po upływie interwału. Następnie w funkcji oddzwaniania zmieniasz licznik czasu po zakończeniu pracy, a nie wcześniej. Przykład:

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

Dlatego nie ma potrzeby stosowania mechanizmów blokujących, ponieważ nie ma współbieżności. Timer uruchomi następne wywołanie zwrotne po upływie następnego interwału + czas długotrwałej operacji.

Jeśli chcesz uruchomić stoper z dokładnością do N milisekund, proponuję zmierzyć czas długotrwałej operacji za pomocą Stopwatch, a następnie odpowiednio wywołać metodę Change:

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

I zdecydowanie zachęcić ktoś robi .NET i wykorzystuje CLR, który nie czytać książki Jeffreya Richtera - CLR via C # , aby przeczytać to jak najszybciej. Liczniki czasu i pule wątków są tam szczegółowo wyjaśnione.

Nie ma potrzeby zatrzymywania timera, zobacz fajne rozwiązanie z tego postu :

„Możesz pozwolić zegarowi na kontynuowanie wywoływania metody wywołania zwrotnego, ale opakuj kod, który nie jest ponownie wprowadzany, w Monitor.TryEnter / Exit. W takim przypadku nie ma potrzeby zatrzymywania / restartowania licznika czasu; nakładające się wywołania nie uzyskają blokady i nie powrócą natychmiast.”

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

Czy używanie jest System.Threading.Timerobowiązkowe?

Jeśli nie, System.Timers.Timerma przydatne Start()i Stop()metody (i AutoResetwłaściwość, którą możesz ustawić na false, aby Stop()nie było potrzebne i po prostu wywołujesz Start()po wykonaniu).

Po prostu zrobiłbym:

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
  }

I zignoruj ​​parametr okresu, ponieważ próbujesz samodzielnie kontrolować okresy.

Oryginalny kod działa tak szybko, jak to możliwe, skoro trzymasz określając 0dla dueTimeparametru. Od Timer.Change:

Jeśli dueTime ma wartość zero (0), metoda wywołania zwrotnego jest wywoływana natychmiast.

 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)

jeśli lubisz użyć jakiejś pętli w środku ...

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.