這是背景線程隊列高性能實現嗎？

Question

具體而言，我想知道：

ManualResetEvent在處於等待狀態時會消耗資源嗎？上下文切換的性能下降是否適用於處於等待狀態的線程？

如果我可以選擇使用多個BackgroundThreadQueues來減少每個工作，或者使用一個BackgroundThreadQueue來做更多的工作，並且我選擇使用多個...將等待的線程隊列影響進程的性能，而他們沒有做任何事情？

是否有更好的FIFO線程隊列，我應該在C＃中使用，還是採用不同的鎖定策略？

任何建議表示讚賞。

/// <summary> 
/// This class is responsible for peforming actions in a FIFO order on a 
/// background thread. When it is constructed, a background thread is created 
/// and a manual reset event is used to trigger actions to be performed when 
/// a new action is enqueued, or when one finishes. There is a ShuttingDown 
/// flag that is set by calling code when it is time to destroy the thread, 
/// and a QueueIsEmpty event is fired whenever the queue finishes executing 
/// the last action. 
/// </summary> 
public class BackgroundThreadQueue : IBackgroundThreadQueue 
{ 
    #region Fields 

    private readonly Queue<Action> queueOfActions = new Queue<Action>(); 
    readonly ManualResetEvent resetEvent; 
    private bool shuttingDown; 
    private bool readyToShutdown; 
    private readonly object lockObject = new object(); 
    private string queuName; 

    #endregion Fields 

    #region Events 

    /// <summary> 
    /// Occurs when the BackgroundThreadQueue is empty, and ready to shut down. 
    /// </summary> 
    public event EventHandler IsReadyToShutdown; 

    #endregion Events 

    #region Constructor 

    public BackgroundThreadQueue(string threadName) 
    { 
     this.resetEvent = new ManualResetEvent(false); 
     queuName = threadName; 
     StartThread(); 
    } 

    #endregion Constructor 

    #region Public Methods 

    public void ClearQueue() 
    { 
     lock (lockObject) 
     { 
      queueOfActions.Clear(); 
     } 
     resetEvent.Set(); 
    } 

    /// <summary> 
    /// Enqueues an action, and calls set on the manual reset event to trigger 
    /// the action to be performed (if no action is currently being performed, 
    /// the one just enqueued will be done immediately, if an action is already 
    /// being performed, then the one just enqueued will have to wait its turn). 
    /// </summary> 
    public void EnqueueAction(Action actionToEnqueue) 
    { 
     if (actionToEnqueue == null) 
     { 
      throw new ArgumentNullException("actionToEnqueue"); 
     } 

     bool localReadyToShutDown = false; 
     lock (lockObject) 
     { 
      queueOfActions.Enqueue(actionToEnqueue); 

      if(this.readyToShutdown) 
      { 
       localReadyToShutDown = true; 
       this.readyToShutdown = false; 
      } 
     } 

     //if this instance is ready to shut down...and we just enqueued a 
     //new action...we can't shut down now... 
     if (localReadyToShutDown) 
     { 
      StartThread(); 
     } 
     resetEvent.Set(); 
    } 

    #endregion Public Methods 

    #region Public Properties 

    public bool ReadyToShutdown 
    { 
     get 
     { 
      lock (lockObject) 
      { 
       return this.shuttingDown && this.readyToShutdown; 
      } 
     } 
     private set 
     { 
      this.readyToShutdown = value; 
      if (this.readyToShutdown) 
      { 
       //let interested parties know that the queue is now empty 
       //and ready to shutdown 
       IsReadyToShutdown.Raise(this); 
      } 
     } 
    } 

    /// <summary> 
    /// Gets or sets a value indicating whether or not the queue should shut down 
    /// when it is finished with the last action it has enqueued to process. 
    /// If the queues owner is shutting down, it needs to notify the queue, 
    /// and wait for a QueueIsEmpty event to be fired, at which point the reset 
    /// event will exit ... the owner shouldn't actually destroy the queue 
    /// until all actions have been performed. 
    /// </summary> 
    public bool ShuttingDown 
    { 
     get 
     { 
      lock (lockObject) 
      { 
       return this.shuttingDown; 
      } 
     } 
     set 
     { 
      lock (lockObject) 
      { 
       bool startThread = false; 
       if (value == false) 
       { 
        readyToShutdown = false; 
        //if we were shutting down...but, now are not 
        startThread = this.shuttingDown; 
       } 

       this.shuttingDown = value; 

       //if we were shutting down, but now are not... 
       //we need to restart the processing actions thread 
       if (startThread) 
       { 
        StartThread(); 
       } 
      } 

      this.resetEvent.Set(); 
     } 
    } 

    #endregion Public Properties 

    #region Private Methods 

    private void StartThread() 
    { 
     var processActionsThread = new Thread(this.ProcessActions); 
     processActionsThread.Name = queuName; 
     processActionsThread.IsBackground = true; 
     processActionsThread.Start();    
    } 

    /// <summary> 
    /// Processes the actions in a while loop, resetting a ManualResetEvent that 
    /// is triggered in the EnqueueAction method and ShuttingDown property. 
    /// </summary> 
    private void ProcessActions() 
    { 
     while (true) 
     { 
      Action action = null; 
      lock (lockObject) 
      { 
       //if there are any actions, then get the first one out of the queue 
       if (queueOfActions.Count > 0) 
       { 
        action = queueOfActions.Dequeue(); 
       } 
      } 
      if (action != null) 
      { 
       action(); 
      } 
      lock (lockObject) 
      { 
       //if any actions were added since the last one was processed, go 
       //back around the loop and do the next one 
       if (this.queueOfActions.Count > 0) 
       { 
        continue; 
       } 

       if (this.shuttingDown) 
       { 
        //ReadyToShutdown setter will raise IsReadyToShutdown 
        ReadyToShutdown = true; 
        //get out of the method if the user has chosen to shutdown, 
        //and there are no more actions to process 
        return; 
       }      
       this.resetEvent.Reset(); 
      } 

      this.resetEvent.WaitOne(); 
     } 
    } 

    #endregion Private Methods 
} 

Answer 1

等待線程的存在本身應該有超出保留容納線程的堆棧實際內存沒有正在進行的性能影響，以及任何會計信息的運行時間或內核保持對於他們。所以不，真正等待的線程除了消耗RAM之外不會做任何事情。

這就是說，我不確定爲什麼要編寫這些代碼，因爲.Net內建了一個線程池，並且您應該更喜歡自己的併發工具。

Answer 2

在調用ManualResetEvent.WaitOne()時被阻塞的線程從CPU中被取消，並且不會再被OS調度，直到應該喚醒它的事件（即調用Set()）爲止。因此，在等待被髮信號時，它們處於不活動狀態並且不消耗CPU週期。