C#实现自定义线程池实例代码

    public class Task
    {
        #region Variable
        //一个AutoResetEvent实例
        private AutoResetEvent _locks = new AutoResetEvent(false);
        //一个Thread实例
        private Thread _thread;
        // 绑定回调方法，就是外部实际执行的任务
        public Action _taskAction;

        //定义一个事件用来绑定工作完成后的操作，也就是4中所说的工作队列向空闲队列移动
        public event Action<Task> WorkComplete;

        /// <summary>
        ///设置线程拥有的Key
        /// </summary>
        public string Key { get; set; }

        #endregion

        //线程需要做的工作
        private void Work()
        {
            while (true)
            {
                //判断信号状态，如果有set那么 _locks.WaitOne()后的程序就继续执行
                _locks.WaitOne();
                _taskAction();
                //执行事件
                WorkComplete(this);
            }
        }

        #region event
        //构造函数
        public Task()
        {
            //スレッドオブジェクトを初期化する
            _thread = new Thread(Work);
            _thread.IsBackground = true;
            Key = Guid.NewGuid().ToString();
            //线程开始执行
            _thread.Start();
        }

        //Set开起信号
        public void Active()
        {
            _locks.Set();
        }

        #endregion
    }

    public class TaskPool
    {
        #region Variable
        //创建的线程数
        private int _threadCount;
        //空闲线程队列
        private Queue<Task> _freeQueue;
        //工作线程字典（为什么？）
        private Dictionary<string, Task> _workingDictionary;
        //空闲队列，存放需要被执行的外部函数
        private Queue<Action> _waitQueue;
        #endregion

        #region Event
        //自定义线程池的构造函数
        public TaskPool()
        {
            _workingDictionary = new Dictionary<string, Task>();
            _freeQueue = new Queue<Task>();
            _waitQueue = new Queue<Action>();
            _threadCount = 10;

            Task task = null;
            //产生固定数目的线程
            for (int i = 0; i < _threadCount; i++)
            {
                task = new Task();
                //给每一个任务绑定事件
                task.WorkComplete += new Action<Task>(WorkComplete);
                //将每一个新创建的线程放入空闲队列中
                _freeQueue.Enqueue(task);
            }
        }

        //线程任务完成之后的工作
        void WorkComplete(Task obj)
        {
            lock (this)
            {
                //将线程从字典中排除
                _workingDictionary.Remove(obj.Key);
                //将该线程放入空闲队列
                _freeQueue.Enqueue(obj);

                //判断是否等待队列中有任务未完成
                if (_waitQueue.Count > 0)
                {
                    //取出一个任务
                    Action item = _waitQueue.Dequeue();
                    Task newTask = null;
                    //空闲队列中取出一个线程
                    newTask = _freeQueue.Dequeue();
                    // 线程执行任务
                    newTask._taskAction = item;
                    //把线程放入到工作队列当中
                    _workingDictionary.Add(newTask.Key, newTask);
                    //设置信号量
                    newTask.Active();
                    return;
                }
                else
                {
                    return;
                }
            }
        }

        //添加任务到线程池
        public void AddTaskItem(Action taskItem)
        {
            lock (this)
            {
                Task task = null;
                //判断空闲队列是否存在线程
                if (_freeQueue.Count > 0)
                {
                    //存在线程，取出一个线程
                    task = _freeQueue.Dequeue();
                    //将该线程放入工作队列
                    _workingDictionary.Add(task.Key, task);
                    //执行传入的任务
                    task._taskAction = taskItem;
                    //设置信号量
                    task.Active();
                    return;
                }
                else
                {
                    //空闲队列中没有空闲线程，就把任务放到等待队列中
                    _waitQueue.Enqueue(taskItem);
                    return;
                }
            }
        }
        #endregion
    }

    class Program
    {
        static void Main(string[] args)
        {
            TaskPool _taskPool = new TaskPool();

            Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
            for (var i = 0; i < 20; i++)
            {
                _taskPool.AddTaskItem(Print);
            }
            Console.Read();
        }

        public static void Print()
        {
            Console.WriteLine("Do Something!");
        }
    }

        public Task()
        {
            _thread = new Thread(Work);
            _thread.IsBackground = true;
            Key = Guid.NewGuid().ToString();
            //线程开始执行
            _thread.Start();
            Console.WriteLine("Thread:"+_thread.ManagedThreadId+" has been created!");
        }

        private void Work()
        {
            while (true)
            {
                //判断信号状态，如果有set那么 _locks.WaitOne()后的程序就继续执行
                _locks.WaitOne();
                _taskAction();
                Console.WriteLine("Thread:" + Thread.CurrentThread.ManagedThreadId+"workComplete");
                //执行事件
                WorkComplete(this);
            }
        }

    class Program
    {
        static void Main(string[] args)
        {
            TaskPool _taskPool = new TaskPool();

            for (var i = 0; i < 20; i++)
            {
                _taskPool.AddTaskItem(Print);
            }
            Console.Read();
        }

        public static void Print()
        {
            Thread.Sleep(10000);
        }
    }