好吧，我已经搜索了很多解决方案。我正在寻找一种干净简单的方法来防止 System.Threading.Timer 的回调方法在我停止后被调用。
我似乎找不到任何东西，这导致我偶尔求助于可怕的 thread-thread.sleep-thread.abort 组合。
可以用锁来完成吗？
【问题讨论】：
标签： c# multithreading timer
一个更简单的解决方案可能是将Timer 设置为永不恢复；方法Timer.Change 可以采用dueTime 和period 的值，指示计时器永不重新启动：
this.Timer.Change(Timeout.Infinite, Timeout.Infinite);
虽然改用System.Timers.Timer 可能是一个“更好”的解决方案，但总会有不切实际的时候；只需使用Timeout.Infinite 就足够了。
【讨论】：
like Conrad Frix 建议您应该改用System.Timers.Timer 类，例如：
private System.Timers.Timer _timer = new System.Timers.Timer();
private volatile bool _requestStop = false;
public constructor()
{
_timer.Interval = 100;
_timer.Elapsed += OnTimerElapsed;
_timer.AutoReset = false;
_timer.Start();
}
private void OnTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
{
// do work....
if (!_requestStop)
{
_timer.Start();//restart the timer
}
}
private void Stop()
{
_requestStop = true;
_timer.Stop();
}
private void Start()
{
_requestStop = false;
_timer.Start();
}
【讨论】：
AutoReset 设置为 false 并不能解决任何问题，但是我错误地将其留在那里..
MSDN Docs 建议您使用Dispose(WaitHandle) 方法来停止计时器+在不再调用回调时得到通知。
【讨论】：
对于 System.Threading.Timer，可以执行以下操作（还将保护回调方法不处理已处置的计时器 - ObjectDisposedException）：
class TimerHelper : IDisposable
{
private System.Threading.Timer _timer;
private readonly object _threadLock = new object();
public event Action<Timer,object> TimerEvent;
public void Start(TimeSpan timerInterval, bool triggerAtStart = false,
object state = null)
{
Stop();
_timer = new System.Threading.Timer(Timer_Elapsed, state,
System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite);
if (triggerAtStart)
{
_timer.Change(TimeSpan.FromTicks(0), timerInterval);
}
else
{
_timer.Change(timerInterval, timerInterval);
}
}
public void Stop(TimeSpan timeout = TimeSpan.FromMinutes(2))
{
// Wait for timer queue to be emptied, before we continue
// (Timer threads should have left the callback method given)
// - http://woowaabob.blogspot.dk/2010/05/properly-disposing-systemthreadingtimer.html
// - http://blogs.msdn.com/b/danielvl/archive/2011/02/18/disposing-system-threading-timer.aspx
lock (_threadLock)
{
if (_timer != null)
{
ManualResetEvent waitHandle = new ManualResetEvent(false)
if (_timer.Dispose(waitHandle))
{
// Timer has not been disposed by someone else
if (!waitHandle.WaitOne(timeout))
throw new TimeoutException("Timeout waiting for timer to stop");
}
waitHandle.Close(); // Only close if Dispose has completed succesful
_timer = null;
}
}
}
public void Dispose()
{
Stop();
TimerEvent = null;
}
void Timer_Elapsed(object state)
{
// Ensure that we don't have multiple timers active at the same time
// - Also prevents ObjectDisposedException when using Timer-object
// inside this method
// - Maybe consider to use _timer.Change(interval, Timeout.Infinite)
// (AutoReset = false)
if (Monitor.TryEnter(_threadLock))
{
try
{
if (_timer==null)
return;
Action<Timer, object> timerEvent = TimerEvent;
if (timerEvent != null)
{
timerEvent(_timer, state);
}
}
finally
{
Monitor.Exit(_threadLock);
}
}
}
}
这是如何使用它的：
void StartTimer()
{
TimerHelper _timerHelper = new TimerHelper();
_timerHelper.TimerEvent += (timer,state) => Timer_Elapsed();
_timerHelper.Start(TimeSpan.FromSeconds(5));
System.Threading.Sleep(TimeSpan.FromSeconds(12));
_timerHelper.Stop();
}
void Timer_Elapsed()
{
// Do what you want to do
}
【讨论】：
为了它的价值，我们经常使用这种模式：
// set up timer
Timer timer = new Timer(...);
...
// stop timer
timer.Dispose();
timer = null;
...
// timer callback
{
if (timer != null)
{
..
}
}
【讨论】：
我已经阅读了很多关于如何在网上同步处理System.Threading.Timer 的废话。所以这就是为什么我发布这个试图在某种程度上纠正这种情况。如果我写的东西有问题，请随时告诉我/打电话给我;-)
在我看来存在以下陷阱：
Timer.Dispose(WaitHandle) 可以返回 false。如果它已经被处理（我必须查看源代码），它会这样做。在这种情况下，它不会设置WaitHandle - 所以不要等待它！WaitHandle 超时。说真的 - 如果您对超时不感兴趣，您还在等什么？ObjectDisposedException 可能发生在处理期间（而不是处理之后）。Timer.Dispose(WaitHandle) 不能与 -Slim 等待句柄一起正常工作，或者与预期不同。例如，以下操作不起作用（它永远阻塞）： using(var manualResetEventSlim = new ManualResetEventSlim)
{
timer.Dispose(manualResetEventSlim.WaitHandle);
manualResetEventSlim.Wait();
}
我猜这个标题有点“粗体”，但下面是我处理这个问题的尝试——一个处理双重处理、超时和ObjectDisposedException的包装器。虽然它没有提供 Timer 上的所有方法 - 但请随意添加它们。
internal class Timer
{
private readonly TimeSpan _disposalTimeout;
private readonly System.Threading.Timer _timer;
private bool _disposeEnded;
public Timer(TimeSpan disposalTimeout)
{
_disposalTimeout = disposalTimeout;
_timer = new System.Threading.Timer(HandleTimerElapsed);
}
public event Action Elapsed;
public void TriggerOnceIn(TimeSpan time)
{
try
{
_timer.Change(time, Timeout.InfiniteTimeSpan);
}
catch (ObjectDisposedException)
{
// race condition with Dispose can cause trigger to be called when underlying
// timer is being disposed - and a change will fail in this case.
// see
// https://msdn.microsoft.com/en-us/library/b97tkt95(v=vs.110).aspx#Anchor_2
if (_disposeEnded)
{
// we still want to throw the exception in case someone really tries
// to change the timer after disposal has finished
// of course there's a slight race condition here where we might not
// throw even though disposal is already done.
// since the offending code would most likely already be "failing"
// unreliably i personally can live with increasing the
// "unreliable failure" time-window slightly
throw;
}
}
}
private void HandleTimerElapsed(object state)
{
Elapsed?.Invoke();
}
public void Dispose()
{
var waitHandle = new ManualResetEvent(false));
// returns false on second dispose
if (_timer.Dispose(waitHandle))
{
if (waitHandle.WaitOne(_disposalTimeout))
{
_disposeEnded = true;
waitHandle.Dispose();
}
else
{
// don't dispose the wait handle, because the timer might still use it.
// Disposing it might cause an ObjectDisposedException on
// the timer thread - whereas not disposing it will
// result in the GC cleaning up the resources later
throw new TimeoutException(
"Timeout waiting for timer to stop. (...)");
}
}
}
}
【讨论】：
using 有什么好处？假设WaitOne(x) 以ArgumentOutOfRangeException 失败 - 会发生什么？我不认为ManualResetEvent 在这种情况下会被处理掉。根据文档，ManualResetEvent.Dispose() 在任何情况下都不会引发异常，因此using 隐藏另一个异常也不应该有问题。
WaitOne 返回 true 时进行处理。
您不能保证应该停止计时器的代码会在计时器事件调用之前执行。 例如，假设在时间点 0，您初始化计时器以在时间点 5 到来时调用事件。然后在时间点 3，您决定不再需要该呼叫。并调用你想在这里写的方法。然后，当方法是 JIT-ted 时，时间点 4 和操作系统决定你的线程耗尽它的时间片并切换。无论您如何尝试，计时器都会调用该事件 - 您的代码在最坏的情况下将没有机会运行。
这就是为什么在事件处理程序中提供一些逻辑更安全的原因。也许一些 ManualResetEvent 将在您不再需要事件调用时立即重置。所以你 Dispose 定时器，然后设置 ManualResetEvent。在计时器事件处理程序中，您首先要做的是测试 ManualResetEvent。如果它处于重置状态 - 立即返回。因此，您可以有效地防止某些代码的意外执行。
【讨论】：
对我来说，这似乎是正确的方法：
完成计时器后，只需致电dispose。这将停止计时器并阻止未来的预定呼叫。
请参阅下面的示例。
class Program
{
static void Main(string[] args)
{
WriteOneEverySecond w = new WriteOneEverySecond();
w.ScheduleInBackground();
Console.ReadKey();
w.StopTimer();
Console.ReadKey();
}
}
class WriteOneEverySecond
{
private Timer myTimer;
public void StopTimer()
{
myTimer.Dispose();
myTimer = null;
}
public void ScheduleInBackground()
{
myTimer = new Timer(RunJob, null, 1000, 1000);
}
public void RunJob(object state)
{
Console.WriteLine("Timer Fired at: " + DateTime.Now);
}
}
【讨论】：
也许你应该做相反的事情。使用 system.timers.timer，将 AutoReset 设置为 false 并仅在需要时启动它
【讨论】：
您可以通过创建这样的类并从例如您的回调方法调用它来停止计时器：
public class InvalidWaitHandle : WaitHandle
{
public IntPtr Handle
{
get { return InvalidHandle; }
set { throw new InvalidOperationException(); }
}
}
实例化计时器：
_t = new Timer(DisplayTimerCallback, TBlockTimerDisplay, 0, 1000);
然后内部回调方法：
if (_secondsElapsed > 80)
{
_t.Dispose(new InvalidWaitHandle());
}
【讨论】：
有一个 MSDN 链接如何正确实现停止计时器。使用ControlThreadProc() 方法和HandleElapsed(object sender, ElapsedEventArgs e) 事件，由syncPoint 静态类变量同步。如果不合适（可能），请在 ControlThreadProc() 上注释掉 Thread.Sleep(testRunsFor);。
关键是在条件语句上使用静态变量和像Interlocked.CompareExchange 这样的原子操作。
【讨论】：