如何判断线程是否成功退出？

Question

根据 ThreadState 的 MSDN 文档，已停止可以通过以下两种方式之一进入状态：线程退出或线程被中止。

是否有某种机制可以判断线程是否通过正常退出而进入 Stopped 状态？ 谢谢！

Answer 1

线程可以通过多种方式达到停止状态：

• 它的 main 方法可以退出而没有任何错误。
• 线程上未捕获的异常可以终止它。
• 另一个线程可以调用 Thread.Abort()，这将导致该线程抛出 ThreadAbortException。

我不知道您是否想要区分所有三种状态，但如果您真正感兴趣的是线程是否成功完成，我建议使用某种共享数据结构（同步字典可以工作）线程的主循环在终止时更新。 您可以使用 ThreadName 属性作为此共享字典中的键。 对终止状态感兴趣的其他线程可以从此字典中读取以确定线程的最终状态。

详细查看 MSDN 文档后，您应该能够使用 ThreadState 属性区分外部中止的线程。 当线程响应 Abort() 调用时，应将其设置为 ThreadState.Aborted。 但是，除非您可以控制运行的线程代码，否则我认为您无法区分刚刚退出其 main 方法的线程和因异常终止的线程。

但请记住，如果您控制启动线程的代码，您始终可以替换自己的方法，该方法在内部调用运行主线程逻辑并注入异常检测的代码（如上所述）那里。

Answer 2

是您想要监视代码的线程吗？ 如果是这样，您可以将整个事情包装在一个类中，并在完成时引发一个事件或使用 WaitHandle （我将使用 ManualResetEvent）来表示完成。 -- 完全封装后台逻辑。 您还可以使用此封装来捕获异常，然后引发事件。

像这样的东西：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace BackgroundWorker
{
    public class BackgroundWorker
    {
        /// 
        /// Raised when the task completes (you could enhance this event to return state in the event args)
        /// 
        public event EventHandler TaskCompleted;

        /// 
        /// Raised if an unhandled exception is thrown by the background worker
        /// 
        public event EventHandler BackgroundError;

        private ThreadStart BackgroundTask;
        private readonly ManualResetEvent WaitEvent = new ManualResetEvent(false);

        /// 
        /// ThreadStart is the delegate that  you want to run on your background thread.
        /// 
        /// 
        public BackgroundWorker(ThreadStart backgroundTask)
        {
            this.BackgroundTask = backgroundTask;
        }

        private Thread BackgroundThread;

        /// 
        /// Starts the background task
        /// 
        public void Start()
        {
            this.BackgroundThread = new Thread(this.ThreadTask);
            this.BackgroundThread.Start();

        }

        private void ThreadTask()
        {
            // the task that actually runs on the thread
            try
            {
                this.BackgroundTask();
                // completed only fires on successful completion
                this.OnTaskCompleted(); 
            }
            catch (Exception e)
            {
                this.OnError(e);
            }
            finally
            {
                // signal thread exit (unblock the wait method)
                this.WaitEvent.Set();
            }

        }

        private void OnTaskCompleted()
        {
            if (this.TaskCompleted != null)
                this.TaskCompleted(this, EventArgs.Empty);
        }

        private void OnError(Exception e)
        {
            if (this.BackgroundError != null)
                this.BackgroundError(this, new BackgroundWorkerErrorEventArgs(e));
        }

        /// 
        /// Blocks until the task either completes or errrors out
        /// returns false if the wait timed out.
        /// 
        /// Timeout in milliseconds, -1 for infinite
        /// 
        public bool Wait(int timeout)
        {
            return this.WaitEvent.WaitOne(timeout);
        }

    }


    public class BackgroundWorkerErrorEventArgs : System.EventArgs
    {
        public BackgroundWorkerErrorEventArgs(Exception error) { this.Error = error; }
        public Exception Error;
    }

}

注意：您需要一些代码来防止 Start 被调用两次，并且您可能需要添加一个状态属性来将状态传递给您的线程。

这是一个控制台应用程序，演示了此类的用法：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BackgroundWorker
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Test 1");
            BackgroundWorker worker = new BackgroundWorker(BackgroundWork);
            worker.TaskCompleted += new EventHandler(worker_TaskCompleted);
            worker.BackgroundError += new EventHandler(worker_BackgroundError);
            worker.Start();
            worker.Wait(-1);

            Console.WriteLine("Test 2");
            Console.WriteLine();

            // error case
            worker = new BackgroundWorker(BackgroundWorkWithError);
            worker.TaskCompleted += new EventHandler(worker_TaskCompleted);
            worker.BackgroundError += new EventHandler(worker_BackgroundError);
            worker.Start();
            worker.Wait(-1);

            Console.ReadLine();
        }

        static void worker_BackgroundError(object sender, BackgroundWorkerErrorEventArgs e)
        {
            Console.WriteLine("Exception: " + e.Error.Message);
        }

        private static void BackgroundWorkWithError()
        {
            throw new Exception("Foo");
        }

        static void worker_TaskCompleted(object sender, EventArgs e)
        {
            Console.WriteLine("Completed");
        }

        private static void BackgroundWork()
        {
            Console.WriteLine("Hello!");
        }
    }
}

Answer 3

您可能想查看BackgroundWorker 类。 它有一个线程完成时的通用事件处理程序。 在那里您可以检查线程是否由于错误而完成、因为它被取消或因为它成功完成。

Answer 4

假设主线程需要等待工作线程成功完成，我通常使用ManualResetEvent。 或者，对于多个工作线程，Parallels Extensions 中的新 CountDownEvent，例如 所以。

Answer 5

我使用 CancellationTokenSource 来要求线程正常退出。

然后，我使用 var exitedProperly = _thread.Join(TimeSpan.FromSeconds(10); 等待线程退出。

如果 exitedProperly==false，我会将错误推送到 我主要

在使用 Dispose() 函数时使用此模式，并且尝试清理我创建的所有线程。

Answer 6

线程只能通过调用 Thread.Abort() 来中止，这会导致 ThreadAbortException，因此通过异常处理，您应该能够确定正常退出与中止退出。