STATION_COLLECT/services/TaskExecManager.cs

using AmrControl.Common;
using AmrControl.JGR;
using System.Collections.Concurrent;

namespace AmrControl.services
{
    public class TaskExecManager : ITaskExecManager
    {
        /// <summary>
        /// 任务列表
        /// </summary>
        private ConcurrentQueue<Dictionary<string, Proxy>> tasks = new();
        /// <summary>
        /// 进行中的任务
        /// </summary>
        private volatile string? curTaskId;
        /// <summary>
        /// 运行状态
        /// </summary>
        private volatile bool _running;
        /// <summary>
        /// 完成任务列表
        /// </summary>
        private volatile List<string> completedTasks = new();

        /// <summary>
        /// 锁对象
        /// </summary>
        Mutex mutex = new Mutex();

        private static volatile TaskExecManager Instance = null;
        public TaskExecManager()
        {
            Instance = this;
        }

        public static ITaskExecManager getInstance()
        {
            return Instance;
        }
        /// <summary>
        /// 添加任务
        /// </summary>
        /// <param name="proxy"></param>
        /// <param name="taskId"></param>
        public void addTask(Proxy proxy, string taskId)
        {
            tasks.Enqueue(new Dictionary<string, Proxy>() { { taskId, proxy } });
        }
        /// <summary>
        /// 检查任务是否完成
        /// </summary>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public bool checkTaskIsCompleted(string taskId)
        {
            try
            {
                mutex.WaitOne();
                return completedTasks.Remove(taskId);
            }
            finally
            {
                mutex.ReleaseMutex();
            }
        }
        /// <summary>
        /// 生成任务id
        /// </summary>
        /// <returns></returns>
        public string genTaskId()
        {
            return Guid.NewGuid().ToString();
        }

        /// <summary>
        /// 通知任务完成
        /// </summary>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public void notifyTaskCompleted(string taskId)
        {
            try
            {
                mutex.WaitOne();
                completedTasks.Add(taskId);
            }
            finally
            {
                mutex.ReleaseMutex();
            }
        }

        public void start()
        {
            if (!_running)
            {
                _running = true;
                startTask();
            }

        }

        public void stop()
        {
            //修改运行状态标识
            _running = false;
        }

        async void startTask()
        {
            while (_running)
            {
                Dictionary<string, Proxy> taskDic = null;
                _ = tasks.TryDequeue(out taskDic);
                if (taskDic != null)
                {
                    try
                    {
                        curTaskId = taskDic.Keys.First();
                        //将当前任务id放入线程上下文
                        ThreadLocalManager.Set(new ThreadLocalContext() { taskId = curTaskId });
                        taskDic[curTaskId].Invoke();
                        ////等待任务完成
                        //do
                        //{
                        //    await Task.Delay(TimeSpan.FromMilliseconds(300));
                        //} while (!checkTaskIsCompleted(curTaskId));
                    } catch (Exception ex)
                    {
                        Console.WriteLine($"执行任务产生异常，异常原因:${ex.Message}");
                    }
                    //finally
                    //{
                    //    ThreadLocalManager.Remove();
                    //}
                }
                else
                {
                    await Task.Delay(TimeSpan.FromMilliseconds(300));
                }

            }
        }
    }
}