如何在 ElapsedEvent 期间保持 System.Timers.Timer 停止

Question

我正在使用 System.Timers.Timer 并且每隔 x 秒我需要在 ElapsedEvent 方法中执行一些任务。当我在 ElapsedEvent 方法中执行任务时，我希望停止计时器。但是，我有另一种可以启动计时器的方法，可以在 ElapsedEvent 运行时调用它。我的代码如下所示：

class MyClass {
   Timer myTimer;

   public MyClass {
      myTimer = new System.Timers.Timer();
      // init timer code here...
   }

   public void ElapsedEventTask(object source, ElapsedEventArgs e) {
      myTimer.Enabled = false;
      try
      {
          // do my tasks
      }
      catch
      {
         ...
      }
      finally
      {
         myTimer.Enabled = true;
      }
   }
}

public void AnotherMethod() {
   // do some things
   myTimer.Enabled = true;
}

当我完成ElapsedEventTask 中的任务时，如何防止AnotherMethod 启动计时器？

Answer 1

您可以添加一个变量来指示任务是否正在运行。最后为了线程安全，当这个变量与myTimer.Enabled一起使用时，你需要使用lock：

class MyClass
{
    object syncEnableRunning = new object();
    bool running
    Timer myTimer;

    public void ElapsedEventTask(object source, ElapsedEventArgs e)
    {
        lock(syncEnableRunning)
        {
            running = true;
            myTimer.Enabled = false;
        }
        
        try { /*do my tasks*/}
        catch { ... }
        finally
        {
            lock(syncEnableRunning)
            {
                myTimer.Enabled = true;
                running = false;
            }
        }
    }

    public void AnotherMethod()
    {
        // do some things
        lock(syncEnableRunning)
        {
            if(!running)
            {
                myTimer.Enabled = true;
            }
        }
    }
}

Answer 2

根据documentation，System.Timers.Timer 类不是线程安全的，因此在没有同步的情况下从多个线程触摸其Enabled 属性是不安全的（这样做会导致未定义的行为）。 Vernou 的answer 展示了如何使用锁来同步线程，但我个人对尝试使用显然被设计为可重入的机制强制执行非重叠执行策略感到有些紧张。所以我的建议是放弃System.Timers.Timer，改用异步循环，由Stephen Cleary 的PauseTokenSource 机制控制：

class MyClass
{
    private readonly CancellationTokenSource _cts;
    private readonly PauseTokenSource _pts;
    public Task Completion { get; private set; }

    public MyClass(TimeSpan interval)
    {
        _cts = new CancellationTokenSource();
        _pts = new PauseTokenSource();
        _pts.IsPaused = true;
        Completion = Task.Run(async () =>
        {
            try
            {
                while (true)
                {
                    await _pts.Token.WaitWhilePausedAsync(_cts.Token);
                    var delayTask = Task.Delay(interval, _cts.Token);
                    /* Do my tasks */
                    await delayTask;
                }
            }
            catch (OperationCanceledException)
                when (_cts.IsCancellationRequested) { } // Ignore
        });
    }

    public void Start() => _pts.IsPaused = false;
    public void Stop() => _pts.IsPaused = true;
    public void Complete() => _cts.Cancel();
}

PauseTokenSource 是 PauseToken 的控制器，与 CancellationTokenSource/CancellationToken 组合的概念类似。区别在于CancellationTokenSource 只能取消一次，而PauseTokenSource 可以多次暂停/取消暂停。这个类包含在AsyncEx.Coordination 包中。

MyClass 公开了一个终止异步循环的Complete 方法，以及一个可以等待的Completion 属性。在关闭程序之前await 这个属性是个好主意，让任何活动操作都有机会完成。否则进程可能会在后台执行过程中被杀死，后果无法预料。

Answer 3

我会创建一个一次性计时器，然后您需要在计时器功能结束时重新启动它。

myTimer = new System.Timers.Timer();
myTimer.AutoReset = false;


public void ElapsedEventTask(object source, ElapsedEventArgs e) {
  ...
  finally
  {
     myTimer.Start();
  }

}