轻量级短请求快速处理线程池

        在实时控制领域的调度中，上位机与设备间的交互依赖各种通信，这些通信往往会在短时间内并发发起，但是每个通信连接上的阻塞时间都很短，基本都是在毫秒级，甚至是微妙级，为了降低线程池的高并发和线程时间片的切换，在一些场合可以利用串行的处理换取并行处理的高资源占用。

        该线程池的设计依据便是将处理线程单独剥离出来，通过监听对应的消息队列处理入队的消息，外部需要处理的数据通过消息队列入口压入，为了达到周期性的数据处理的目的，构造看门狗定时器，定时器会周期性的向消息队列泵入处理信号，处理线程内部，在接收泵入的外部信号后，进行消息队列中的消息快速处理。

          当要处理的消息的处理周期结束时，在下一次的信号到达时会自动进行回收清理。

 /// <summary>    /// 自定义线程池接口    /// </summary>    public interface IManualThreadPool    {        /// <summary>        /// 启动        /// </summary>        void Start();        /// <summary>        /// 压入处理数据        /// </summary>        /// <param name="poolData"></param>        void PostData(ManualTimerPoolData poolData);        /// <summary>        /// 停止        /// </summary>        void Stop();        /// <summary>        /// 是否正在运行        /// </summary>        /// <returns>        /// 返回运行状态        /// </returns>        bool IsRunning();        /// <summary>        /// 线程池启动后触发事件        /// </summary>        event ManualPoolCallback OnPoolStartedCallback;        /// <summary>        /// 线程池停止后触发事件        /// </summary>        event ManualPoolCallback OnPoolStopedCallback;        /// <summary>        /// 开始执行请求的数据        /// </summary>        event ManualPoolCallback OnStartExcuteCallback;        /// <summary>        /// 结束执行请求的数据        /// </summary>        event ManualPoolCallback OnEndExcuteCallback;    }

 

 /// <summary>    /// 自定义定时器型线程池    /// 属于轻量级线程池,此线程用于需要延时或等待处理的场合，但是实际调用很短暂的场合    /// </summary>    public class ManualTimerThreadPool:IManualThreadPool    {        /// <summary>        /// 定时处理消息定时器        /// </summary>        ITimer timer = null;        /// <summary>        /// 正常处理的消息队列        /// </summary>        IoCompletionMessageFIFO normalFIFO = new IoCompletionMessageFIFO();        /// <summary>        /// 正常处理数据链表        /// </summary>        private List<ManualTimerPoolData> normalManualTimerPoolDataList = new List<ManualTimerPoolData>();        /// <summary>        /// 是否正在运行        /// </summary>        private volatile bool isRunning = false;        /// <summary>        /// 是否可以处理消息        /// </summary>        private volatile bool isCanReciveMessage = false;        /// <summary>        /// 停止时通知信号量        /// </summary>        private ManualResetEvent manualResetEvent = new ManualResetEvent(false);        /// <summary>        /// 线程池处理构造函数        /// </summary>        /// <param name="period">线程池调度周期</param>        public ManualTimerThreadPool(int period)            : this(0, period, ManualPoolTimerType.单线程高速定时器)        {        }        /// <summary>        /// 线程池处理构造函数        /// </summary>        /// <param name="dueTime">线程池延迟启动时间</param>        /// <param name="period">线程池调度周期</param>        /// <param name="timerType">定时器类型</param>        public ManualTimerThreadPool(int dueTime, int period, ManualPoolTimerType timerType)        {            if (timerType == ManualPoolTimerType.单线程高速定时器)            {                timer = new SingleThreadTimer(dueTime, period);            }            else if (timerType == ManualPoolTimerType.双线程缓冲定时器)            {                timer = new DoubleThreadTimer(dueTime, period);            }            else if (timerType == ManualPoolTimerType.线程池并行定时器)            {                timer = new ThreadPoolParallelTimer(dueTime, period);            }            timer.OnRunningCallback += timer_OnRunningCallback;            normalFIFO.OnStarted += normalFIFO_OnStarted;            normalFIFO.Exceute += normalFIFO_Exceute;        }        /// <summary>        /// 开启消息队列        /// </summary>        /// <param name="obj"></param>        void normalFIFO_OnStarted(object obj)        {            normalFIFO.Post(ManualThreadPoolCommand.Start);        }        /// <summary>        /// 正常处理队列执行数据处理        /// </summary>        /// <param name="obj"></param>        void normalFIFO_Exceute(object obj)        {            if (obj is ManualThreadPoolCommand)            {                ManualThreadPoolCommand command = (ManualThreadPoolCommand)obj;                if (command == ManualThreadPoolCommand.Start)                {                    this.normalManualTimerPoolDataList = new List<ManualTimerPoolData>();                    try                    {                        if (OnPoolStartedCallback != null)                        {                            ManualTimerPoolData tempPoolData = new ManualTimerPoolData("启动");                            OnPoolStartedCallback(this, new ManualPoolEventArgs(tempPoolData));                        }                    }                    catch                    {                    }                    finally                    {                        isCanReciveMessage = true;                    }                }                else if (command == ManualThreadPoolCommand.Stop)                {                    if (normalManualTimerPoolDataList != null && normalManualTimerPoolDataList.Count > 0)                    {                        for (int i = 0; i < normalManualTimerPoolDataList.Count; i++)                        {                            ManualTimerPoolData poolData = normalManualTimerPoolDataList[i];                            if (poolData.ManualPoolExcuteStatus == ManualPoolExcuteStatus.就绪)                            {                                try                                {                                    if (OnStartExcuteCallback != null)                                    {                                        OnStartExcuteCallback(this, new ManualPoolEventArgs(poolData));                                    }                                }                                catch                                {                                }                                finally                                {                                    poolData.ManualPoolExcuteStatus = ManualPoolExcuteStatus.执行;                                }                            }                            if (poolData.ManualPoolExcuteStatus == ManualPoolExcuteStatus.执行)                            {                                try                                {                                    if (OnEndExcuteCallback != null)                                    {                                        OnEndExcuteCallback(this, new ManualPoolEventArgs(poolData));                                    }                                }                                catch                                {                                }                                finally                                {                                    poolData.ManualPoolExcuteStatus = ManualPoolExcuteStatus.结束;                                }                            }                        }                        this.normalManualTimerPoolDataList = new List<ManualTimerPoolData>();                        try                        {                            if (OnPoolStopedCallback != null)                            {                                ManualTimerPoolData tempPoolData = new ManualTimerPoolData("停止");                                OnPoolStopedCallback(this, new ManualPoolEventArgs(tempPoolData));                            }                        }                        catch                        {                        }                        finally                        {                            isCanReciveMessage = false;                            manualResetEvent.Set();                        }                    }                }                else if (command == ManualThreadPoolCommand.Running)                {                    if (isCanReciveMessage == false)                    {                        return;                    }                    if (normalManualTimerPoolDataList != null && normalManualTimerPoolDataList.Count > 0)                    {                        List<ManualTimerPoolData> removeManualTimerPoolDataList = new List<ManualTimerPoolData>();                        for (int i = 0; i < normalManualTimerPoolDataList.Count; i++)                        {                            ManualTimerPoolData poolData = normalManualTimerPoolDataList[i];                            if (poolData.ManualPoolExcuteStatus == ManualPoolExcuteStatus.就绪)                            {                                if ((DateTime.Now - poolData.BeginDate).TotalMilliseconds > poolData.DelayStartExcuteTimeOut)                                {                                    try                                    {                                        if (OnStartExcuteCallback != null)                                        {                                            OnStartExcuteCallback(this, new ManualPoolEventArgs(poolData));                                        }                                    }                                    catch                                    {                                    }                                    finally                                    {                                        poolData.ManualPoolExcuteStatus = ManualPoolExcuteStatus.执行;                                    }                                }                            }                            if (poolData.ManualPoolExcuteStatus == ManualPoolExcuteStatus.执行)                            {                                if ((DateTime.Now - poolData.BeginDate).TotalMilliseconds > poolData.ExcuteTimeOut)                                {                                    try                                    {                                        if (OnEndExcuteCallback != null)                                        {                                            OnEndExcuteCallback(this, new ManualPoolEventArgs(poolData));                                        }                                    }                                    catch                                    {                                    }                                    finally                                    {                                        poolData.ManualPoolExcuteStatus = ManualPoolExcuteStatus.结束;                                    }                                }                            }                            if (poolData.ManualPoolExcuteStatus == ManualPoolExcuteStatus.结束)                            {                                removeManualTimerPoolDataList.Add(poolData);                            }                        }                        if (removeManualTimerPoolDataList.Count > 0)                        {                            for (int i = 0; i < removeManualTimerPoolDataList.Count; i++)                            {                                ManualTimerPoolData removePoolData = removeManualTimerPoolDataList[i];                                normalManualTimerPoolDataList.Remove(removePoolData);                            }                        }                    }                }            }            else if (obj is ManualTimerPoolData)            {                if (isCanReciveMessage == false)                {                    return;                }                ManualTimerPoolData poolData = (ManualTimerPoolData)obj;                if (poolData.ManualPoolExcuteStatus == ManualPoolExcuteStatus.就绪)                {                    if ((DateTime.Now - poolData.BeginDate).TotalMilliseconds > poolData.DelayStartExcuteTimeOut)                    {                        try                        {                            if (OnStartExcuteCallback != null)                            {                                OnStartExcuteCallback(this, new ManualPoolEventArgs(poolData));                            }                        }                        catch                        {                        }                        finally                        {                            poolData.ManualPoolExcuteStatus = ManualPoolExcuteStatus.执行;                        }                    }                }                if (poolData.ManualPoolExcuteStatus == ManualPoolExcuteStatus.执行)                {                    if ((DateTime.Now - poolData.BeginDate).TotalMilliseconds > poolData.ExcuteTimeOut)                    {                        try                        {                            if (OnEndExcuteCallback != null)                            {                                OnEndExcuteCallback(this, new ManualPoolEventArgs(poolData));                            }                        }                        catch                        {                        }                        finally                        {                            poolData.ManualPoolExcuteStatus = ManualPoolExcuteStatus.结束;                        }                    }                }                if (poolData.ManualPoolExcuteStatus != ManualPoolExcuteStatus.结束)                {                     this.normalManualTimerPoolDataList.Add(poolData);                }            }        }        /// <summary>        /// 周期性回调处理        /// </summary>        /// <param name="sender"></param>        /// <param name="e"></param>        void timer_OnRunningCallback(object sender, EventArgs e)        {            if (normalFIFO != null && normalFIFO.IsOpened == true)            {                normalFIFO.Post(ManualThreadPoolCommand.Running);            }        }        /// <summary>        /// 启动        /// </summary>        public void Start()        {            if (isRunning == false)            {                if (timer != null)                {                    timer.Start();                }                if (normalFIFO != null && normalFIFO.IsOpened == false)                {                    normalFIFO.Start();                }                isRunning = true;            }        }        /// <summary>        /// 压入线程池要处理的数据        /// </summary>        /// <param name="poolData"></param>        public void PostData(ManualThreadPool.ManualTimerPoolData poolData)        {            if (normalFIFO != null && normalFIFO.IsOpened == true)            {                normalFIFO.Post(poolData);            }        }        /// <summary>        /// 停止        /// </summary>        public void Stop()        {            if (timer != null)            {                timer.Stop();            }            if (normalFIFO != null && normalFIFO.IsOpened == true)            {                manualResetEvent.Reset();                normalFIFO.Post(ManualThreadPoolCommand.Stop);                manualResetEvent.WaitOne(2000);                normalFIFO.Stop();            }            isRunning = false;        }        /// <summary>        /// 判断当前线程池的运行状态        /// </summary>        /// <returns></returns>        public bool IsRunning()        {            return isRunning;        }        /// <summary>        /// 线程池启动后触发事件        /// </summary>        public event ManualPoolCallback OnPoolStartedCallback;        /// <summary>        /// 线程池停止后触发事件        /// </summary>        public event ManualPoolCallback OnPoolStopedCallback;        /// <summary>        /// 开始执行请求        /// </summary>        public event ManualThreadPool.ManualPoolCallback OnStartExcuteCallback;        /// <summary>        /// 结束执行请求        /// </summary>        public event ManualThreadPool.ManualPoolCallback OnEndExcuteCallback;    }