在windows服務上優雅地關閉前臺線程

Question

在我的Windows服務中，我創建了一個「父」前臺線程，它使用ThreadPool（這意味着它們是後臺）產生執行任務的「子」線程。

在Windows服務停止時優雅地關閉前臺線程的最佳方式是什麼？

這是我目前的執行（剝出特定任務的邏輯）：

public partial class TaskScheduler : ServiceBase 
{ 
    private static AutoResetEvent _finishedTaskAutoResetEvent = new AutoResetEvent(false); 

    //This flag is used to increase chances of the Spawning Thread to finish gracefully when service stops. 
    private bool StopRequested { get; set; } 

    private int _executingTasksCount; 

    private int ExecutingTasksCount { get { return _executingTasksCount; } } 

    private void IncCurrentTasksCount() 
    { 
     Interlocked.Increment(ref _executingTasksCount); 
    } 

    private void DecCurrentTasksCount() 
    { 
     Interlocked.Decrement(ref _executingTasksCount); 
    } 

    public TaskScheduler() 
    { 
     InitializeComponent(); 

     Thread spawningThread = new Thread(DoSpawnTaskExecutionThreads); 

     spawningThread.Name = "Spawning Thread"; 
     spawningThread.IsBackground = false; 
     spawningThread.Start(); 
    } 

    protected override void OnStart(string[] args) 
    { 
    } 

    protected override void OnStop() 
    { 
     StopRequested = true; 
    } 

    private void DoSpawnTaskExecutionThreads() 
    { 
     //We check StopRequested to try and finish this thread gracefully when service stops. 
     while (!StopRequested) 
     { 
      while (!StopRequested && ExecutingTasksCount < MaxPooledTasks) 
      { 
       ThreadPool.QueueUserWorkItem(ExecuteTask, new Task()); 

       IncCurrentTasksCount(); 
      } 

      _finishedTaskAutoResetEvent.WaitOne(); 
     } 

     //Either all task execution threads will finish or the process will be terminated forcibly. 
     while (ExecutingTasksCount > 0) 
     { 
      Thread.Sleep(200); //Check five times a second. 
     } 

     _eventLog.WriteEntry("The Spawning Thread finished along with task execution threads."); 
    } 

    private void ExecuteTask(object state) 
    { 
     try 
     { 
      Task task = (Task)state; 

      task.Execute(); 
     } 
     catch 
     { 
      // Handle exception. 
     } 
     finally 
     { 
      DecCurrentTasksCount(); 
      _finishedTaskAutoResetEvent.Set(); 
     } 
    } 

}

Answer 1

我看到了一些代碼問題。

• StopRequested的檢查不是線程安全的。
• ExecutingTaskCount的檢查不是線程安全的。
• 由於_finishedTaskAutoResetEvent是一個AutoResetEvent信號可能會丟失，因爲該WaitHandle不保留一個計數。也許這就是你想要的，但它可能會導致嵌套的while循環的一些奇怪的旋轉。

下面是我將如何重構你的代碼。它使用.NET 4.0中提供的CountdownEvent類。

public class TaskScheduler : ServiceBase 
{ 
    private m_Stop as ManualResetEvent = new ManualResetEvent(false); 

    protected override void OnStart(string[] args)   
    {   
     var thread = new Thread(DoSpawnTaskExecutionThreads); 
     thread.Name = "Spawning Thread"; 
     thread.IsBackground = false; 
     thread.Start(); 
    }   

    protected override OnStop() 
    { 
     m_Stop.Set(); 
    } 

    public DoSpawnTaskExecutionThreads() 
    { 
     // The semaphore will control how many concurrent tasks can run. 
     var pool = new Semaphore(MaxPooledThreads, MaxPooledThreads); 

     // The countdown event will be used to wait for any pending tasks. 
     // Initialize the count to 1 so that we treat this thread as if it 
     // were a work item. This is necessary to avoid a subtle race 
     // with a real work item that completes quickly. 
     var tasks = new CountdownEvent(1); 

     // This array will be used to control the spinning of the loop. 
     var all = new WaitHandle[] { pool, m_Stop }; 

     while (WaitHandle.WaitAny(all) == 0) 
     { 
     // Indicate that there is another task. 
     tasks.AddCount(); 

     // Queue the task. 
     Thread.QueueUserWorkItem(
      (state) => 
      { 
      try 
      { 
       var task = (Task)state; 
       task.Execute(); 
      } 
      finally 
      { 
       pool.Release(); // Allow another task to be queued. 
       tasks.Signal(); // Indicate that this task is complete. 
      } 
      }, new Task()); 
     } 

     // Indicate that the main thread is complete. 
     tasks.Signal(); 

     // Wait for all pending tasks. 
     tasks.Wait(); 
    } 
} 

Answer 2

有一個問題，我在這裏看到：

StopRequested不應該是一個自動財產。您應該將其定義爲具有後臺字段的屬性，以便將其標記爲​​。

private volatile bool stopRequested; 
private bool StopRequested 
{ 
    get { return this.stopRequested; } 
    set { this.stopRequested = value; } 
} 

沒有這一點，這是可能的退出條件，可能無法察覺（至少就）通過你的線程時，它是由服務設置。另外，如果.NET 4是一個選項，那麼使用CancellationToken和BlockingCollection<T>可以完成更簡單的設計。

Answer 3

您可以使用Join方法「優雅地」殺死該線程。 MSDN有關於該方法的一些信息。