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

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

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

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

 /// <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;
    }