System.Threading.Timer trong C # có vẻ như không hoạt động. Nó chạy rất nhanh sau mỗi 3 giây

Tôi có một đối tượng hẹn giờ. Tôi muốn nó được chạy mỗi phút. Cụ thể, nó sẽ chạy một OnCallBackphương thức và không hoạt động trong khi một OnCallBackphương thức đang chạy. Khi một OnCallBackphương thức kết thúc, nó (a OnCallBack) khởi động lại bộ đếm thời gian.

Đây là những gì tôi có ngay bây giờ:

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
}

Tuy nhiên, nó dường như không hoạt động. Nó chạy rất nhanh sau mỗi 3 giây. Ngay cả khi tăng một khoảng thời gian (1000 * 10). Có vẻ như nó nhắm mắt làm ngơ1000 * 10

Tôi đã làm gì sai?

Đây không phải là cách sử dụng chính xác của System.Threading.Timer. Khi bạn khởi tạo Bộ hẹn giờ, hầu như bạn luôn phải làm như sau:

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

Điều này sẽ hướng dẫn bộ hẹn giờ chỉ đánh dấu một lần khi khoảng thời gian đã trôi qua. Sau đó, trong chức năng Gọi lại của bạn, bạn Thay đổi bộ hẹn giờ khi công việc đã hoàn thành, không phải trước đó. Thí dụ:

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

Do đó không cần cơ chế khóa vì không có đồng thời. Bộ hẹn giờ sẽ kích hoạt lệnh gọi lại tiếp theo sau khi khoảng thời gian tiếp theo trôi qua + thời gian hoạt động dài.

Nếu bạn cần chạy bộ đếm thời gian của mình ở chính xác N mili giây, thì tôi khuyên bạn nên đo thời gian của hoạt động chạy dài bằng Đồng hồ bấm giờ và sau đó gọi phương thức Thay đổi một cách thích hợp:

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

Tôi đặc biệt khuyến khích những ai đang làm .NET và đang sử dụng CLR chưa đọc sách của Jeffrey Richter - CLR qua C # , hãy đọc càng sớm càng tốt. Bộ hẹn giờ và nhóm chủ đề được giải thích rất chi tiết ở đó.

Không cần thiết phải dừng hẹn giờ, hãy xem giải pháp hay từ bài đăng này :

"Bạn có thể để bộ hẹn giờ tiếp tục kích hoạt phương thức gọi lại nhưng bọc mã không đăng nhập lại của bạn trong Monitor.TryEnter / Exit. Không cần dừng / khởi động lại bộ hẹn giờ trong trường hợp đó; các cuộc gọi chồng chéo sẽ không nhận được khóa và quay lại ngay lập tức."

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

Sử dụng có System.Threading.Timerbắt buộc không?

Nếu không, System.Timers.Timercó các phương thức Start()và tiện dụng Stop()(và một thuộc AutoResettính bạn có thể đặt thành false, do đó Stop()không cần thiết và bạn chỉ cần gọi Start()sau khi thực thi).

Tôi sẽ chỉ là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
  }

Và bỏ qua thông số chu kỳ, vì bạn đang cố gắng tự mình kiểm soát chu kỳ.

Mã ban đầu của bạn đang chạy nhanh nhất có thể, vì bạn tiếp tục chỉ định 0cho dueTimetham số. Từ Timer.Change:

Nếu doTime bằng không (0), phương thức gọi lại được gọi ngay lập tức.

 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)

nếu bạn thích sử dụng một số chuỗi vòng lặp bên trong ...

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.