可执行任务取消处理线程池

周末闲来无事，把思考了很久的一个线程池处理算法，实现了，总结了一下设计的思路和设计的初衷。

在进行多线程异步任务调用时，我们经常会用到.net中的线程池System.Threading.ThreadPool.QueueUserWorkItem，随着微软在线程池调度算法上的优化，线程池的效率和智能化等方面，越来越高，但是该线程池，也存在操作的缺陷，比如发起一个异步的大数据保存操作，执行数据保存可能需要耗时时间很长，在此过程中，用户可能发现前端数据输入有问题，需要取消操作，如果用默认的线程池，进行异步操作，由于线程池中的线程采用智能分配和调度，我们没法取消对应的线程操作，数据保存还在异步线程中执行着，最终得到不是需要的结果。

如果需要对任务可取消操作，又不丢失线程池的灵活性和方便性，我们需要自定义可执行任务取消处理的线程池，调用接口与原线程池一致，但是增加了取消任务的调用操作。

自定义线程的设计思路是，利用托管线程消息队列，负责所有的异步消息的分发和路由，同时利用托管线程消息队列，进行资源的管理，因为托管线程消息队列，已执行了消息的线程间同步，策略算法的处理，就不需要线程间的二次同步处理。

考虑到该线程池的场合，是分场景的，因此没有做成全局静态入口线程池，但可在调用处独立实例化封装为全局静态入口线程池。

整个设计流程思路：

核心调度算法代码,核心算法中用到了周期性的消息处理队列，这个在其他文章，介绍线程池时，有介绍，此处不再描述：

/// <summary>
    /// 手工，带队列缓冲，可取消任务处理线程池
    /// </summary>
    public class ManualQueueThreadPool
    {
        /// <summary>
        /// 容器托管线程
        /// </summary>
        private ITimerMessageFIFO dockerMessageFIFO = null;
        /// <summary>
        /// 等待被执行的任务列表
        /// </summary>
        private List<ManualTask> waitManualTaskList = new List<ManualTask>();
        /// <summary>
        /// 工作线程列表
        /// </summary>
        private List<WorkThreadInfo> workThreadInfoList = new List<WorkThreadInfo>();
        /// <summary>
        /// 最大工作线程数量
        /// </summary>
        private int maxWorkThreadCount = 10;
        /// <summary>
        /// 最大工作线程数量
        /// </summary>
        public int MaxWorkThreadCount
        {
            get 
            {
                return maxWorkThreadCount;
            }
        }
        /// <summary>
        /// 最大的自由线程数量
        /// </summary>
        private int maxFreeThreadCount = 2;
        /// <summary>
        /// 最大空闲线程数量，空闲线程，用于随时执行新的调度
        /// </summary>
        public int MaxFreeThreadCount
        {
            get 
            {
                return maxFreeThreadCount;
            }
        }
        private int initWorkThreadCount = 3;
        /// <summary>
        /// 默认启动初始化线程数量
        /// </summary>
        public int InitWorkThreadCount
        {
            get 
            {
                return initWorkThreadCount;
            }
        }
        private int freeWorkThreadCollectTimeOut = 10;
        /// <summary>
        /// 空闲线程，回收处理超时时间，单位是分钟
        /// </summary>
        public int FreeWorkThreadCollectTimeOut
        {
            get 
            {
                return freeWorkThreadCollectTimeOut;
            }
        }
        /// <summary>
        /// 是否正在关闭
        /// </summary>
        private volatile bool onClosing = false;
        /// <summary>
        /// 创建线程池
        /// </summary>
        /// <param name="initWorkThreadCount">默认启动初始化线程数量，默认3个</param>
        /// <param name="maxFreeThreadCount">最大空闲线程数量，空闲线程，用于随时执行新的调度，默认2个</param>
        /// <param name="maxWorkThreadCount">最大工作线程数量，默认10个</param>
        /// <param name="freeWorkThreadCollectTimeOut">空闲线程回收超时时间，单位是分钟，默认10分钟</param>
        /// <returns>
        /// 返回创建的线程池
        /// </returns>
        public static ManualQueueThreadPool Create(int initWorkThreadCount = 3, int maxFreeThreadCount = 2, int maxWorkThreadCount = 10,int freeWorkThreadCollectTimeOut=10)
        {
            ManualQueueThreadPool manualQueueThreadPool = new ManualQueueThreadPool();
            manualQueueThreadPool.initWorkThreadCount = initWorkThreadCount;
            manualQueueThreadPool.maxFreeThreadCount = maxFreeThreadCount;
            manualQueueThreadPool.maxWorkThreadCount = maxWorkThreadCount;
            manualQueueThreadPool.freeWorkThreadCollectTimeOut = freeWorkThreadCollectTimeOut;
            return manualQueueThreadPool;
        }
        private ManualQueueThreadPool()
        { 
        
        }
        /// <summary>
        /// 启动
        /// </summary>
        public void Open()
        {
            this.InnerStartDocker();
            ManualTaskCommandInfo taskCommandInfo = new ManualTaskCommandInfo(ManualTaskCommand.StartWorkThreads);
            this.PushDockerMessageFIFO(taskCommandInfo);
        }
        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            this.onClosing = true;
            ManualTaskCommandInfo taskCommandInfo = new ManualTaskCommandInfo(ManualTaskCommand.CloseWorkThreads);
            this.PushDockerMessageFIFO(taskCommandInfo);
            this.InnerStopDocker();
        }
        /// <summary>
        /// 内部启动
        /// </summary>
        private void InnerStartDocker()
        {
            if (dockerMessageFIFO == null)
            {
                dockerMessageFIFO = TimerMessageFIFO.Create(new ManualTimer.TimerParameters(200, 5000), MessageFIFOType.LockMessageFIFO);//5秒钟一次进行资源查询
                dockerMessageFIFO.MessageCallBack += dockerMessageFIFO_MessageCallBack;
                dockerMessageFIFO.SignalCallBack += dockerMessageFIFO_SignalCallBack;
            }
            if (dockerMessageFIFO != null)
            {
                if (dockerMessageFIFO.IsRunning() == false)
                {
                    dockerMessageFIFO.Start();
                }
            }
        }
        /// <summary>
        /// 启动工作线程列表
        /// </summary>
        private void InnerStartWorkThreadList()
        {
            for (int i = 0; i < initWorkThreadCount; i++)
            {
                IMessageFIFO workMessageFIFO = MessageFIFOFactory.Create(MessageFIFOType.LockMessageFIFO);
                workMessageFIFO.Excute += workMessageFIFO_Excute;
                workMessageFIFO.Start();
                WorkThreadInfo workThreadInfo = new WorkThreadInfo(workMessageFIFO);
                this.workThreadInfoList.Add(workThreadInfo);
            }
        }
        /// <summary>
        /// 执行具体的工作线程处理
        /// </summary>
        /// <param name="obj"></param>
        private void workMessageFIFO_Excute(object obj)
        {
            if (obj is ManualTask)
            {
                ManualTask task = (ManualTask)obj;
                task.WaitCallback.Invoke(task.Data);
            }
        }
        /// <summary>
        /// 停止工作线程列表
        /// </summary>
        private void InnerStopWorkThreadList()
        {
            if (this.workThreadInfoList==null || this.workThreadInfoList.Count == 0)
            {
                return;
            }
            for (int i = 0; i < this.workThreadInfoList.Count; i++)
            {
                WorkThreadInfo info = this.workThreadInfoList[i];
                if (info.WorkThread != null && info.WorkThread.IsOpened == true)
                {
                    info.WorkThread.ForceStop();
                }
            }
            this.workThreadInfoList.Clear();
        }
        /// <summary>
        /// 压入数据到内部消息处理队列
        /// </summary>
        /// <param name="data">数据</param>
        private void PushDockerMessageFIFO(object data)
        {
            if (dockerMessageFIFO == null || dockerMessageFIFO.IsRunning() == false)
            {
                if (onClosing == false)
                {
                    InnerStartDocker();
                }
            }
            if (dockerMessageFIFO != null && dockerMessageFIFO.IsRunning() == true)
            {
                dockerMessageFIFO.PostData(data);
            }
        }
        /// <summary>
        /// 周期性的信号反馈，用于将缓存队列中的待处理任务，泵入工作线程，或对空闲线程进行释放
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="data"></param>
        private void dockerMessageFIFO_SignalCallBack(object sender, bool data)
        {
            #region 释放掉，已关闭的工作线程
            this.workThreadInfoList.RemoveAll(delegate(WorkThreadInfo tempWorkThreadInfo)
            {
                return tempWorkThreadInfo.WorkThread == null || tempWorkThreadInfo.WorkThread.IsOpened == false; 
            });
            #endregion
            #region 将缓存队列中的数据压入工作线程组
            if (this.waitManualTaskList.Count > 0)//从缓存队列中获取
            {
                for (int i = 0; i < this.workThreadInfoList.Count; i++)
                {
                    WorkThreadInfo tempWorkThreadInfo = this.workThreadInfoList[i];
                    if (tempWorkThreadInfo.WorkThread != null
                        && tempWorkThreadInfo.WorkThread.IsOpened == true
                        && tempWorkThreadInfo.WorkThread.WaitExcuteTaskCount <= 0)
                    {
                        if (this.waitManualTaskList.Count > 0)
                        {
                            ManualTask tempManualTask = this.waitManualTaskList[0];
                            tempWorkThreadInfo.PostTask(tempManualTask);
                            this.waitManualTaskList.Remove(tempManualTask);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
            #endregion
            #region 构建新的线程，用于处理缓存队列中的数据
            if (this.waitManualTaskList.Count > 0)
            {
                if (this.workThreadInfoList.Count >= maxWorkThreadCount)//线程已达到最大用量，还存在未执行的任务
                {
                    return;
                }
                for (int i = 0; i < this.waitManualTaskList.Count; i++)
                {
                    ManualTask tempManualTask = this.waitManualTaskList[i];
                    if (this.workThreadInfoList.Count >= maxWorkThreadCount)
                    {
                        return;
                    }
                    IMessageFIFO workMessageFIFO = MessageFIFOFactory.Create(MessageFIFOType.LockMessageFIFO);
                    workMessageFIFO.Excute += workMessageFIFO_Excute;
                    workMessageFIFO.Start();
                    WorkThreadInfo newWorkThreadInfo = new WorkThreadInfo(workMessageFIFO);
                    this.workThreadInfoList.Add(newWorkThreadInfo);
                    newWorkThreadInfo.PostTask(tempManualTask);
                }
            }
            #endregion
            #region 线程使用未饱和,多余的空闲线程进行资源释放
            int tempFreeThreadCount = 0;
            List<WorkThreadInfo> freeWorkThreadInfoList = null;
            for (int i = 0; i < this.workThreadInfoList.Count; i++)
            {
                WorkThreadInfo workThreadInfo = this.workThreadInfoList[i];
                if (workThreadInfo.WorkThread != null
                    && workThreadInfo.WorkThread.IsOpened == true
                    && workThreadInfo.WorkThread.WaitExcuteTaskCount <= 0
                    && (DateTime.Now - workThreadInfo.LastWorkTime).TotalMinutes > freeWorkThreadCollectTimeOut)
                {
                    tempFreeThreadCount += 1;
                    if (this.workThreadInfoList.Count > (initWorkThreadCount + maxFreeThreadCount)
                        && tempFreeThreadCount > maxFreeThreadCount)
                    {
                        if (freeWorkThreadInfoList == null)
                        {
                            freeWorkThreadInfoList = new List<WorkThreadInfo>();
                        }
                        freeWorkThreadInfoList.Add(workThreadInfo);
                    }
                }
            }
            if (freeWorkThreadInfoList != null)
            {
                for (int i = 0; i < freeWorkThreadInfoList.Count; i++)
                {
                    WorkThreadInfo workThreadInfo = freeWorkThreadInfoList[i];
                    workThreadInfo.WorkThread.Stop();
                    this.workThreadInfoList.Remove(workThreadInfo);
                }
            }
            #endregion
        }
        /// <summary>
        /// 消息处理回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="data"></param>
        private void dockerMessageFIFO_MessageCallBack(object sender, object data)
        {
            if (data is ManualTask)//泵入任务到工作线程
            {
                ManualTask task = (ManualTask)data;
                WorkThreadInfo workThreadInfo = null;
                for (int i = 0; i < this.workThreadInfoList.Count; i++)
                {
                    WorkThreadInfo tempWorkThreadInfo = this.workThreadInfoList[i];
                    if (tempWorkThreadInfo.WorkThread != null
                        && tempWorkThreadInfo.WorkThread.IsOpened == true
                        && tempWorkThreadInfo.WorkThread.WaitExcuteTaskCount <= 0)
                    {
                        workThreadInfo = tempWorkThreadInfo;
                        break;
                    }
                }
                if (workThreadInfo != null)
                {
                    workThreadInfo.PostTask(task);
                    return;
                }
                if (workThreadInfoList.Count >= maxWorkThreadCount)
                {
                    this.waitManualTaskList.Add(task);
                    return;
                }
                IMessageFIFO workMessageFIFO = MessageFIFOFactory.Create(MessageFIFOType.LockMessageFIFO);
                workMessageFIFO.Excute += workMessageFIFO_Excute;
                workMessageFIFO.Start();
                WorkThreadInfo newWorkThreadInfo = new WorkThreadInfo(workMessageFIFO);
                this.workThreadInfoList.Add(newWorkThreadInfo);
                newWorkThreadInfo.PostTask(task);
            }
            else if (data is ManualTaskCommandInfo)
            {
                ManualTaskCommandInfo manualTaskCommandInfo = (ManualTaskCommandInfo)data;
                if (manualTaskCommandInfo.ManualTaskCommand == ManualTaskCommand.StartWorkThreads)//初始化工作线程组
                {
                    this.InnerStartWorkThreadList();
                }
                else if (manualTaskCommandInfo.ManualTaskCommand == ManualTaskCommand.CloseWorkThreads)//结束所有工作线程
                {
                    this.InnerStopWorkThreadList();
                }
                else if (manualTaskCommandInfo.ManualTaskCommand == ManualTaskCommand.CancelTask)//取消某一个任务
                {
                    if (this.waitManualTaskList.Count > 0)//从缓存队列中获取
                    {
                        ManualTask manualTask = this.waitManualTaskList.Find(delegate(ManualTask tempManualTask) 
                        {
                            return tempManualTask.TaskID.Equals(manualTaskCommandInfo.TaskID, StringComparison.OrdinalIgnoreCase); 
                        });
                        if (manualTask != null)
                        {
                            this.waitManualTaskList.Remove(manualTask);
                            return;
                        }
                    }
                    if (this.workThreadInfoList.Count > 0)//从工作线程组中获取
                    {
                        WorkThreadInfo workThreadInfo = this.workThreadInfoList.Find(delegate(WorkThreadInfo tempWorkThreadInfo)
                        {
                            return tempWorkThreadInfo.TaskID.Equals(manualTaskCommandInfo.TaskID, StringComparison.OrdinalIgnoreCase);
                        });
                        if (workThreadInfo != null)
                        {
                            workThreadInfo.WorkThread.ForceStop();
                        }
                        this.workThreadInfoList.Remove(workThreadInfo);
                    }
                }
            }
        }
        /// <summary>
        /// 内部停止
        /// </summary>
        private void InnerStopDocker()
        {
            if (dockerMessageFIFO != null && dockerMessageFIFO.IsRunning() == true)
            {
                dockerMessageFIFO.Stop();
            }
            dockerMessageFIFO = null;
        }
        /// <summary>
        /// 压入处理请求到线程池
        /// </summary>
        /// <param name="taskID">唯一任务ID</param>
        /// <param name="waitCallBack">回调委托</param>
        /// <param name="data">数据</param>
        public void PushTaskToQueue(string taskID,WaitCallback waitCallBack,object data)
        {
            ManualTask task = new ManualTask(taskID, waitCallBack, data);
            this.PushDockerMessageFIFO(task);
        }
        /// <summary>
        /// 取消任务
        /// </summary>
        /// <param name="taskID">任务ID</param>
        public void CancelTask(string taskID)
        {
            ManualTaskCommandInfo cancelManualTaskCommandInfo = new ManualTaskCommandInfo(ManualTaskCommand.CancelTask);
            cancelManualTaskCommandInfo.TaskID = taskID;
            this.PushDockerMessageFIFO(cancelManualTaskCommandInfo);
        }
    }

整个调度算法写完之后，用于替换，Trace.RMI.Server中间件中的，数据处理部分，具体应用场景为，客户端发起TCP会话连接，服务器端监听到连接会话时，将每一次的处理任务数据，发送到线程池，在线程池中具体执行，服务器端的业务处理，监听会话线程结束，监听会话回归连接池。回调时，在处理线程调用会话ID，重新将连接会话调入业务处理线程，进行回调结果处理。由于服务器端的业务处理，可能时间比较长，客户端在异步等待窗口等待，当用户因为等待时间太长，需要取消操作时，服务器端的业务处理，就无法通过连接会话的取消而取消了。新的场景中，通过对应的连接会话ID，传入处理线程池，取消连接会话对应的任务，进一步取消数据存储事务，而达到数据的回滚的目的。