多线程开发：安全的终止工作线程

在多线程开发中，开发人员经常会碰到如何取消工作线程的问题，一般我们不建议使用Thread.Abort()来终止线程，MSDN中Thread.Abort方法的说明：“在调用此方法的线程上引发 ThreadAbortException，以开始终止此线程的过程。调用此方法通常会终止线程。” 所以结束线程最好是让线程主动退出，可以通过变量、事件等方式通知线程。

以下代码是从书本上看到，非常好的解决了如何关闭工作线程的问题：

 public class WorkerThread : IDisposable

    {

        ManualResetEvent m_ThreadHandle;

        Thread m_ThreadObj;

        bool m_EndLoop;

        Mutex m_EndLoopMutex;



        public WorkerThread()

        {

            m_EndLoop = false;

            m_ThreadObj = null;

            m_EndLoopMutex = new Mutex();

            m_ThreadHandle = new ManualResetEvent(false);

            m_ThreadObj = new Thread(Run);

            Name = "Worker Thread";

        }



        public WorkerThread(bool autoStart)

            : this()

        {

            if (autoStart)

            {

                Start();

            }

        }



        public void Start()

        {

            Debug.Assert(m_ThreadObj != null);

            Debug.Assert(m_ThreadObj.IsAlive == false);

            //m_ThreadObj.Start();

        }



        void Run()

        {

            try

            {

                int i = 0;

                while (EndLoop == false)

                {

                    Trace.WriteLine(string.Format("THread is alive, Counter is {0}", i));

                    i++;

                }

            }

           finally

            {



                m_ThreadHandle.Set();

            }

        }



        public void Dispose()

        {

            Kill();

        }



        public void Kill()

        {

            Debug.Assert(m_ThreadObj != null);

            if(IsAlive == false)

            {

                return;

            }



            EndLoop = true;

            Join();

            m_EndLoopMutex.Close();

            m_ThreadHandle.Close();

        }



        public void Join()

        {

            Join(Timeout.Infinite);

        }



        public bool Join(int millisecondsTimeout)

        {

            TimeSpan timeout = TimeSpan.FromMilliseconds(millisecondsTimeout);

            return Join(timeout);

        }



        public bool Join(TimeSpan timeout)

        {

            Debug.Assert(m_ThreadObj != null);

            if (IsAlive == false)

            {

                return true;

            }



            Debug.Assert(Thread.CurrentThread.ManagedThreadId != m_ThreadObj.ManagedThreadId);

            return m_ThreadObj.Join(timeout);

        }



        public string Name

        {

            get

            {

                return m_ThreadObj.Name;

            }

            set

            {

                m_ThreadObj.Name = value;

            }

        }



        public bool IsAlive

        {

            get

            {

                Debug.Assert(m_ThreadObj != null);

                bool handleSignaled = m_ThreadHandle.WaitOne(0, true);

                //如果代码已经执行完毕，但工作线程的IsAlive仍为true，循环等待

                while(handleSignaled == m_ThreadObj.IsAlive)

                {

                    Thread.Sleep(0);

                }

                return m_ThreadObj.IsAlive;

            }

        }

        public override int GetHashCode()

        {

            return m_ThreadObj.GetHashCode();

        }



        public override bool Equals(object obj)

        {

            return m_ThreadObj.Equals(obj);

        }



        public int ManagedThreadId

        {

            get

            {

                return m_ThreadObj.ManagedThreadId;

            }

        }



        public Thread Thread

        {

            get

            {

                return m_ThreadObj;

            }

        }



        protected bool EndLoop

        {

            set

            {

                m_EndLoopMutex.WaitOne();

                m_EndLoop = value;

                m_EndLoopMutex.ReleaseMutex();

            }

            get

            {

                bool result = false;

                m_EndLoopMutex.WaitOne();

                result = m_EndLoop;

                m_EndLoopMutex.ReleaseMutex();

                return result;

            }

        }



        public WaitHandle Handle

        {

            get

            {

                return m_ThreadHandle;

            }

        }



    }