Timer Elapsed事件如何与高优先级线程竞争？

Question

我有一个我想使用的System.Timers.Timer对象，但我不希望绑定到Timer的处理过程干扰正常到高优先级的线程。换句话说，我想说，只要没有别的东西在运行，我想每5秒钟处理一次X0 。。

我怎么能保证我的定时器操作在一个低优先级的方式运行？

Answer 1

有关System.Timers.Timer的好处是您可以通过SynchronizingObject属性分配同步对象，然后利用它来运行Elapsed事件可以控制其优先级的线程。

的ElapsedEventReceiver的实例只是分配给你的计时器的SynchronizingObject财产。

免责声明：我掀起这件事非常快，所以你需要添加自己的收尾使其更加坚固。

public class ElapsedEventReceiver : ISynchronizeInvoke 
{ 
    private Thread m_Thread; 
    private BlockingCollection<Message> m_Queue = new BlockingCollection<Message>(); 

    public ElapsedEventReceiver() 
    { 
     m_Thread = new Thread(Run); 
     m_Thread.Priority = ThreadPriority.BelowNormal; 
     m_Thread.IsBackground = true; 
     m_Thread.Start(); 
    } 

    private void Run() 
    { 
     while (true) 
     { 
      Message message = m_Queue.Take(); 
      message.Return = message.Method.DynamicInvoke(message.Args); 
      message.Finished.Set(); 
     } 
    } 

    public IAsyncResult BeginInvoke(Delegate method, object[] args) 
    { 
     Message message = new Message(); 
     message.Method = method; 
     message.Args = args; 
     m_Queue.Add(message); 
     return message; 
    } 

    public object EndInvoke(IAsyncResult result) 
    { 
     Message message = result as Message; 
     if (message != null) 
     { 
      message.Finished.WaitOne(); 
      return message.Return; 
     } 
     throw new ArgumentException("result"); 
    } 

    public object Invoke(Delegate method, object[] args) 
    { 
     Message message = new Message(); 
     message.Method = method; 
     message.Args = args; 
     m_Queue.Add(message); 
     message.Finished.WaitOne(); 
     return message.Return; 
    } 

    public bool InvokeRequired 
    { 
     get { return Thread.CurrentThread != m_Thread; } 
    } 

    private class Message : IAsyncResult 
    { 
     public Delegate Method; 
     public object[] Args; 
     public object Return; 
     public object State; 
     public ManualResetEvent Finished = new ManualResetEvent(false); 

     public object AsyncState 
     { 
      get { return State; } 
     } 

     public WaitHandle AsyncWaitHandle 
     { 
      get { return Finished; } 
     } 

     public bool CompletedSynchronously 
     { 
      get { return false; } 
     } 

     public bool IsCompleted 
     { 
      get { return Finished.WaitOne(0); } 
     } 
    } 
} 

Answer 2

也许最简单的方法是将有一个“忙”标志（或计数），而忽略只要它是非零的计时器滴答声。

P.S.不建议更改线程优先级。这几乎没有必要。