执行时间超过跨度时的计时器行为

本文关键字：计时器 执行时间 | 更新日期: 2023-09-27 18:20:37

我正在编写windows服务，它将每隔几分钟处理一次"一些东西"。

这里有一些代码：

public Service()
        {
            this.InitializeComponent();
            this.ServiceName = Name;
            this.CanPauseAndContinue = true;
            this.CanShutdown = true;
            this.eventLog.Source = Name;
            // initialize timer
            this.timer.Elapsed += this.TimerElapsed;
        }
        private void TimerElapsed(object sender, ElapsedEventArgs e)
        {
            eventLog.WriteEntry("Starting syncronization...", EventLogEntryType.Information);
            if (this.processor.PrepareToRun())
            {
                this.processor.Run();
            }
        }

我想知道如果this.processor.Run()需要很长时间，并且会引发下一个TimerElapsed事件，会发生什么？它会跳过吗？它会等待并在完成后尽快运行吗？我应该考虑这些场景并为它们编写代码吗？

我正在使用System.Timers.Timer

编辑：

private void TimerElapsed(object sender, ElapsedEventArgs e)
        {
            eventLog.WriteEntry("Starting syncronization...", EventLogEntryType.Information);
            try
            {
                this.timer.Stop();
                if (this.processor.PrepareToRun())
                {
                    this.processor.Run();
                }
            }
            catch (Exception ex)
            {
                LoggingAndNotifications.LogAndNotify(ex);
            }
            finally
            {
                this.timer.Start();
            }
        }

编辑2

public Service()
        {
            this.InitializeComponent();
            this.ServiceName = Name;
            this.CanPauseAndContinue = true;
            this.CanShutdown = true;
            this.eventLog.Source = Name;
            // initialize timer
            this.timer.AutoReset = false;
            this.timer.Elapsed += this.TimerElapsed;
        }
        private void TimerElapsed(object sender, ElapsedEventArgs e)
        {
            eventLog.WriteEntry("Starting syncronization...", EventLogEntryType.Information);
            try
            {
                if (this.processor.PrepareToRun())
                {
                    this.processor.Run();
                }
            }
            catch (Exception ex)
            {
                LoggingAndNotifications.LogAndNotify(ex);
                throw;
            }
            finally
            {
                this.timer.Start();
            }
        }

执行时间超过跨度时的计时器行为

它将在另一个线程上再次调用它。

根据操作的性质，您需要：

  1. 忽略这一点，如果调用的代码对于多个同时调用是安全的，那么这可能没问题。当然，你必须知道这很好
  2. 锁定计时器触发的操作。请注意，最终可能会出现一个包含大量挂起操作的队列，这非常糟糕
  3. 锁定计时器触发的操作，尝试在超时为零的情况下获得锁定，如果失败，则跳过它-上次还有一个线程
  4. 将计时器作为一次性计时器，在每次通话结束时重新启动

您可以看到这个示例应用程序会发生什么：

class Program
{
    static void Main(string[] args)
    {
        System.Timers.Timer timer = new System.Timers.Timer(2000);
        timer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedObject);
        timer.Start();
        while (true)
        {
        }
    }
    static void OnTimedObject(object source, ElapsedEventArgs e)
    {
        Console.WriteLine("entered");
        Thread.Sleep(3000);
        Console.WriteLine("exited");
    }
}

在"exited"第一个出现之前，您将看到两个"entered"字符串出现。它将继续。所以线程不会互相踩在一起。

（顺便说一句，我并不提倡无限循环。：）

如果我不希望后续的定时器触发在方法完成之前再次执行该方法，我会使用以下内容：

private void TimerFired(object sender, System.Timers.ElapsedEventArgs e) {
    // only execute the code within this method if we are able to
    // get a lock. This will ensure that any Timer firings will be
    // ignored that occur while we're already doing work (OnTimer) 
    if (Monitor.TryEnter(lockObj)) {
        try {
            // do work here
        } finally {
            Monitor.Exit(lockObj);
        }
    }
}

否则，如果该方法的持续时间可能比计时器间隔长，则该方法可能在第一个线程完成之前就开始在另一个线程上执行。

当引发计时器事件时，会安排计时器代码在线程池上执行。它很可能会在另一个线程中执行，但它取决于不同的因素（处理器数量、线程利用率等）。然而，它没有定时器——这是线程池的职责。

就我个人而言，我从不使用定时器间隔。我设置定时器运行一次，在我的代码被执行后，再次设置它。因此，我确保代码只在单个线程中执行。

执行时间超过span时的计时器行为？

当任务执行时间超过计时器时间跨度时。TimerExposed事件将引发到一个新线程中。它不会被跳过。在System.Timers.Timer 中实现的多线程

我这样做是为了处理这样的场景。当然，对于多线程操作等特殊情况，您需要对其进行调整。

    public Service()
    {
        bool _IsProcessRunning = false;
        this.InitializeComponent();
        this.ServiceName = Name;
        this.CanPauseAndContinue = true;
        this.CanShutdown = true;
        this.eventLog.Source = Name;
        // initialize timer
        this.timer.Elapsed += this.TimerElapsed;
    }
    private void TimerElapsed(object sender, ElapsedEventArgs e)
    {
        if(!_IsProcessRunning)
        {
            DoSomething();
        }           
    }
    private void DoSomething()
    {
        try
        {
             _IsProcessRunning = true;
             // Do our stuff here
        }
        catch(Exception Ex)
        {               
        }
        finally
        {
             _IsProcessRunning = false;
        }
    }
相关文章：