System.Threading.Timer di C # tampaknya tidak berfungsi. Ini berjalan sangat cepat setiap 3 detik

Saya memiliki objek pengatur waktu. Saya ingin ini dijalankan setiap menit. Secara khusus, itu harus menjalankan OnCallBackmetode dan menjadi tidak aktif saat OnCallBackmetode sedang berjalan. Setelah OnCallBackmetode selesai, itu (a OnCallBack) memulai ulang pengatur waktu.

Inilah yang saya miliki sekarang:

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
}

Namun, sepertinya itu tidak berhasil. Ini berjalan sangat cepat setiap 3 detik. Bahkan jika menaikkan periode (1000 * 10). Sepertinya itu menutup mata1000 * 10

Apa kesalahan yang telah aku perbuat?

Ini bukan penggunaan yang benar dari System.Threading.Timer. Saat Anda memberi contoh Timer, Anda hampir selalu harus melakukan hal berikut:

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

Ini akan menginstruksikan pengatur waktu untuk berdetak hanya sekali ketika jeda telah berlalu. Kemudian dalam fungsi Callback Anda mengubah timer setelah pekerjaan selesai, bukan sebelumnya. Contoh:

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

Jadi tidak perlu mekanisme penguncian karena tidak ada konkurensi. Pengatur waktu akan mengaktifkan panggilan balik berikutnya setelah interval berikutnya telah berlalu + waktu operasi yang berjalan lama.

Jika Anda perlu menjalankan pengatur waktu tepat pada N milidetik, saya sarankan Anda mengukur waktu dari operasi yang berjalan lama menggunakan Stopwatch dan kemudian memanggil metode Ubah dengan tepat:

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

Saya sangat menganjurkan siapa pun yang melakukan .NET dan menggunakan CLR yang belum membaca buku Jeffrey Richter - CLR via C # , untuk membaca secepat mungkin. Pengatur waktu dan kumpulan benang dijelaskan dengan sangat rinci di sana.

Tidak perlu menghentikan timer, lihat solusi bagus dari posting ini :

"Anda dapat membiarkan pengatur waktu terus mengaktifkan metode panggilan balik tetapi membungkus kode non-reentrant Anda di Monitor.TryEnter / Exit. Tidak perlu menghentikan / memulai ulang pengatur waktu dalam hal itu; panggilan yang tumpang tindih tidak akan mendapatkan kunci dan segera kembali."

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

Apakah menggunakan System.Threading.Timerwajib?

Jika tidak, System.Timers.Timermemiliki handy Start()dan Stop()metode (dan AutoResetproperti yang dapat Anda setel ke false, sehingga Stop()tidak diperlukan dan Anda cukup memanggil Start()setelah menjalankan).

Saya hanya akan melakukan:

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
  }

Dan abaikan parameter periode, karena Anda mencoba untuk mengontrol periodicy sendiri.

Kode asli Anda berjalan secepat mungkin, karena Anda tetap menentukan 0untuk dueTimeparameter. Dari Timer.Change:

Jika dueTime nol (0), metode callback dipanggil segera.

 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)

jika Anda suka menggunakan beberapa utas lingkaran di dalam ...

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.