实现一个多线程循环的类

 只要重写protected abstract void DealEvent()即可，这个方法实现多线程的内容，如果内容是循环的，不必在写循环语句， private void CycleDealEvent()方法已经实现了。

  

/**/ /
// 功能:用一个单独的线程进行处理的基类
// 作者:wangjian 
// 时间:2007-9-20
/**/ ///


using  System;
using  System.Threading;


namespace  GDS.ThreadDealEvent
... {
    /**//// <summary>
    /// ThreadBase 的摘要说明
    /// </summary>   
    public abstract class DealEventThreadBase:IDisposable
    ...{
        

        //线程处理运行，安全停止标志
        private bool _dealEventRunFlag = false;

        //强行停止前安全停止等待的时间,单位为妙,默认值为20;
        private uint _stopSpan = 20;

        //是否循环执行DealEvent()
        private bool _cycleDeal = true;

        
        private Thread _dealEventThread;

        /**//// <summary>
        /// 强行停止前安全停止等待的时间,单位为妙,默认值为20;
        /// </summary>
        protected uint StopSpan
        ...{
            get
            ...{
                return _stopSpan;
            }
            set
            ...{
                if (_stopSpan < 1)
                ...{
                    throw new Exception("StopSpan的值要求大于0");
                }
                _stopSpan = value;
            }
        }

        /**//// <summary>
        /// 指示是否循环执行DealEvent()
        /// </summary>
        public bool CycleDeal
        ...{
            get
            ...{
                return _cycleDeal;
            }
        }

        /**//// <summary>
        /// 线程处理运行，安全停止标志
        /// </summary>
        public bool DealEventRunFlag
        ...{
            get
            ...{
                return _dealEventRunFlag;
            }
            set
            ...{
                _dealEventRunFlag = value;
            }
        }

        /**//// <summary>
        /// 处理，由子类重写
        /// </summary>
        protected abstract void DealEvent();

        /**//// <summary>
        /// 循环处理
        /// </summary>
        private void CycleDealEvent()
        ...{
                do
                ...{
                    if (!_dealEventRunFlag)
                        break;
                    try
                    ...{
                        DealEvent();
                    }
                    catch (Exception ex)
                    ...{
                        if (ExceptionEvent != null)
                        ...{
                            ExceptionEvent(ex);
                        }
                    }
                } while (_cycleDeal);  
        }

        /**//// <summary>
        /// 开始线程，如果现存存在则先终止再开始
        /// </summary>
        public virtual void StartDealEventThread()
        ...{
            StartDealEventThread(true);        
        }

        /**//// <summary>
        /// 开始线程，如果现存存在则先终止再开始
        /// </summary>
        /// <param name="cycleDeal">true:循环执行DealEvent();false:执行一次DealEvent()</param>
        public virtual void StartDealEventThread(bool cycleDeal)
        ...{
            if (_dealEventThread != null && (_dealEventThread.ThreadState == ThreadState.Running || _dealEventThread.ThreadState == ThreadState.WaitSleepJoin))
            ...{
                return;
            }

            //确保已经停止
            //StopDealEventThread();
            else
            ...{
                _cycleDeal = cycleDeal;
                _dealEventRunFlag = true;
                _dealEventThread = new Thread(new ThreadStart(CycleDealEvent));
                _dealEventThread.Start();
            }

        }

        /**//// <summary>
        /// 终止线程,如果在20秒内不能按期停止,则强行停止
        /// </summary>
        public virtual void StopDealEventThread()
        ...{
            if (_dealEventThread == null || _dealEventThread.ThreadState == ThreadState.Aborted || _dealEventThread.ThreadState ==ThreadState.AbortRequested ||_dealEventThread.ThreadState == ThreadState.Stopped ||_dealEventThread.ThreadState == ThreadState.Unstarted ||_dealEventThread.ThreadState == ThreadState.StopRequested)
            ...{
                return;
            }
            _dealEventRunFlag = false;
            try
            ...{
                float ThreadAbortFlag = 0;
                while (_dealEventThread.ThreadState != ThreadState.Stopped&&_dealEventThread.ThreadState!=ThreadState.Aborted)
                ...{
                    OnStopDealEvent(new ProgressEventArgs(ThreadAbortFlag / _stopSpan*2));
                    Thread.Sleep(500);
                    ThreadAbortFlag++;
                    if (ThreadAbortFlag > _stopSpan*2)
                    ...{
                        //如果_stopThreadFlag无法停止线程，则等待500*_stopSpan*20毫秒后用Abort()结束
                        _dealEventThread.Abort();                       
                        break;
                    }
                }
                
            }
            catch
            ...{ }          
        }


        /**//// <summary>
        /// 终止线程,如果在StopSpan秒内不能按期停止,则强行停止
        /// </summary>
       /// <param name="StopSpan">安全终止的时间,单位:秒</param>
        public virtual void StopDealEventThread(uint stopSpan)
        ...{
            uint span = stopSpan * 2;
            if (_dealEventThread == null || _dealEventThread.ThreadState == ThreadState.Aborted || _dealEventThread.ThreadState == ThreadState.AbortRequested || _dealEventThread.ThreadState == ThreadState.Stopped || _dealEventThread.ThreadState == ThreadState.Unstarted || _dealEventThread.ThreadState == ThreadState.StopRequested)
            ...{
                return;
            }
            _dealEventRunFlag = false;
            try
            ...{
                float ThreadAbortFlag = 0;
                while (_dealEventThread.ThreadState != ThreadState.Stopped && _dealEventThread.ThreadState != ThreadState.Aborted)
                ...{
                    OnStopDealEvent(new ProgressEventArgs(ThreadAbortFlag / span));
                    Thread.Sleep(500);
                    ThreadAbortFlag++;
                    if (ThreadAbortFlag > span)
                    ...{
                        //如果_stopThreadFlag无法停止线程，则等待500×span毫秒后用Abort()结束
                        _dealEventThread.Abort();
                        break;
                    }
                }

            }
            catch
            ...{ }
        }

        /**//// <summary>
        /// 线程状态
        /// </summary>
        public ThreadState DealEventThreadState
        ...{
            get
            ...{
                try
                ...{
                    return _dealEventThread.ThreadState;
                }
                catch
                ...{
                    return ThreadState.Unstarted;
                }
            }
        }

        IDisposable#region IDisposable
        private bool _disposed = false;
        protected virtual void Dispose(bool disposing)
        ...{
            if (this._disposed)
                return;
            if (disposing)
            ...{
               StopDealEventThread();              
            }                
            
            _disposed = true;
        }
        public void Dispose()
        ...{
            Dispose(true);
        }
        ~DealEventThreadBase()
        ...{
            Dispose(false);
        }
        #endregion 

        /**//// <summary>
        /// 停止进程的进度事件,
        /// </summary>
        public event StopDealEventEventHandler StopDealEvent;
        public event TempEventHandler ExceptionEvent;

        /**//// <summary>
        /// 触发进度事件
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnStopDealEvent(ProgressEventArgs e)
        ...{
            if (StopDealEvent != null)
            ...{
                StopDealEvent(this, e);
            }
        }

        
    }

    /**//// <summary>
    /// 进度事件参数
    /// </summary>
    public class ProgressEventArgs : EventArgs
    ...{
        private float progress;

        public float Progress
        ...{
            get ...{ return progress; }
        }

        /**//// <summary>
        /// 进度事件参数
        /// </summary>
        /// <param name="progress">进度值,大于等于0,小于等于1</param>
        public ProgressEventArgs(float progress)
        ...{
            if (progress < 0 || progress > 1)
            ...{
                throw new Exception("进度值应大于等于0,小于等于1");
            }
            this.progress = progress;            
        }
    }

    /**//// <summary>
    /// 停止进程的进度委托
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public delegate void StopDealEventEventHandler(object sender, ProgressEventArgs e);   
 
    public delegate void TempEventHandler(Exception ex);
    
}