using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Threading;

namespace HXX.Scanner.Biz
{
    public class ThreadPool_manager
    {
        private static CustomThreadPool pool;

        public static void init()
        {
            pool = new CustomThreadPool(5);
        }

        public static void EnqueueTask(Action task)
        {
            pool.EnqueueTask(task);
        }
    }         

    public class CustomThreadPool
    {
        #region 字段
        // 工作线程集合
        private readonly Thread[] _workerThreads;

        // 线程安全任务队列（存储要执行的任务）
        private readonly ConcurrentQueue<Action> _taskQueue = new ConcurrentQueue<Action>();

        // 线程同步信号：通知工作线程有新任务到来
        private readonly ManualResetEventSlim _taskSignal = new ManualResetEventSlim(false);

        // 标记线程池是否已释放
        private bool _isDisposed;
        #endregion

        #region 构造函数
        /// <summary>
        /// 初始化自定义线程池
        /// </summary>
        /// <param name="threadCount">工作线程数量（建议设置为 CPU 核心数）</param>
        public CustomThreadPool(int threadCount)
        {
            if (threadCount <= 0)
                throw new ArgumentOutOfRangeException(nameof(threadCount), "线程数量必须大于 0");

            // 创建固定数量的工作线程
            _workerThreads = new Thread[threadCount];
            for (int i = 0; i < threadCount; i++)
            {
                _workerThreads[i] = new Thread(WorkLoop)
                {
                    IsBackground = true, // 后台线程：进程退出时自动终止
                    Name = $"CustomPoolThread_{i}"
                };
                _workerThreads[i].Start();
            }
        }
        #endregion

        #region 核心方法
        /// <summary>
        /// 向线程池添加任务
        /// </summary>
        /// <param name="task">要执行的任务</param>
        public void EnqueueTask(Action task)
        {
            if (task == null)
                throw new ArgumentNullException(nameof(task));
            if (_isDisposed)
                throw new ObjectDisposedException(nameof(CustomThreadPool));

            // 加入任务队列
            _taskQueue.Enqueue(task);
            // 通知线程：有新任务可以执行
            _taskSignal.Set();
        }

        /// <summary>
        /// 工作线程主循环（持续从队列取任务执行）
        /// </summary>
        private void WorkLoop()
        {
            while (!_isDisposed)
            {
                // 等待任务信号（无任务时阻塞，不占用 CPU）
                _taskSignal.Wait();

                // 线程池已关闭，退出循环
                if (_isDisposed)
                    break;

                // 尝试从队列取出任务并执行
                if (_taskQueue.TryDequeue(out Action task))
                {
                    try
                    {
                        task.Invoke(); // 执行任务
                    }
                    catch
                    {
                        // 这里可以添加任务异常日志（避免单个任务崩溃整个线程）
                    }
                }
                else
                {
                    // 队列空了，重置信号，进入等待状态
                    _taskSignal.Reset();
                }
            }
        }
        #endregion

        #region 释放资源
        /// <summary>
        /// 关闭线程池，释放所有资源
        /// </summary>
        public void Dispose()
        {
            if (_isDisposed)
                return;

            _isDisposed = true;
            _taskSignal.Set(); // 唤醒所有等待的线程

            // 等待所有工作线程退出
            foreach (Thread thread in _workerThreads)
            {
                thread.Join();
            }

            _taskSignal.Dispose();
        }
        #endregion
    }
}