在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有关于该方法的一些信息。