多线程通用处理队列类（一）

最近实现了一个支持多FTP，同时FTP要多线程上传的小项目，通过对线程池的动态管理，很好的解决了同一时刻允许最大线程和空闲线程时任务自动入队的的问题，贴出来给大家使用：

    /// <summary>
    /// 表示一个线程（同步）安全的通用泛型处理队列
    /// </summary>
    /// <typeparam name="T">ProcessQueue中包含的数据类型</typeparam>
    public class ProcessQueue<T> : IEnumerable<T>, ICollection, IEnumerable, IDisposable
    {
        #region Instance Variables

        private object syncRoot = new object();
        private Queue<T> queue;
        private List<WorkerThread> threads = new List<WorkerThread>();
        private Action<T> operation;
        bool isDisposed;
        bool isRunning;

        private int _maxThreadCount;

        public int MaxThreadCount
        {
            get { return _maxThreadCount == 0 ? 5 : _maxThreadCount; }
            set { value = _maxThreadCount; }
        }

        #endregion

        #region Constructors
        /// <summary>
        /// 初始一个新的ProcessQueue 并指定具有特定容量的工作线程
        /// </summary>
        public ProcessQueue(Action<T> action) : this(action, 5) { }
        /// <summary>
        /// 初始一个新的ProcessQueue
        /// </summary>
        public ProcessQueue(int capacity, Action<T> action) : this(capacity, action, 5) { }
        /// <summary>
        /// 初始一个新的ProcessQueue
        /// </summary>
        public ProcessQueue(IEnumerable<T> collection, Action<T> action) : this(collection, action, 5) { }

        /// <summary>
        /// 初始一个新的ProcessQueue
        /// </summary>
        public ProcessQueue(Action<T> action, int threadCount)
        {
            queue = new Queue<T>();
            operation = action;

            SetThreadCount(MaxThreadCount);
        }

        /// <summary>
        /// 初始一个新的ProcessQueue
        /// </summary>
        /// <param name="capacity">初始容量</param>
        public ProcessQueue(int capacity, Action<T> action, int threadCount)
        {
            queue = new Queue<T>(capacity);
            operation = action;

            SetThreadCount(MaxThreadCount);
        }

        /// <summary>
        /// 初始一个新的ProcessQueue
        /// </summary>
        /// <param name="collection">将数据复制到ProcessQueue.</param>
        public ProcessQueue(IEnumerable<T> collection, Action<T> action, int threadCount)
        {
            queue = new Queue<T>(collection);
            operation = action;

            SetThreadCount(MaxThreadCount);
        }
        #endregion

        #region Processing Control

        /// <summary>
        /// 停止 (挂起) 
        /// </summary>
        public void Stop()
        {
            lock (syncRoot)
            {
                foreach (WorkerThread thread in threads)
                {
                    thread.Pause();
                }

                isRunning = false;
            }
        }

        /// <summary>
        /// 开始运行
        /// </summary>
        public void Start()
        {
            lock (syncRoot)
            {
                //清空队列集合重新创建新的线程
                RegenerateIfDisposed();
                //如果新进的项目少于当前线程集合总的线程数，则创建当前新进的项目数
                //如果新进 的项目多余当前线程集合的线程数，则创建同样多的数程集合的线程数
                for (int i = 0; i < Math.Min(threads.Count, queue.Count); i++)
                {
                    //设置信号让其运行
                    threads[i].Signal();
                }
                isRunning = true;
            }
        }

        /// <summary>
        /// 获取此ProcessQueue使用的工作线程数。 使用SetThreadCount更改此值。
        /// </summary>
        public int ThreadCount { get { return threads.Count; } }

        /// <summary>
        /// 设置此ProcessQueue使用的工作线程数，并根据需要分配或释放线程。
        /// </summary>
        /// <param name="threadCount">线程数</param>
        public void SetThreadCount(int threadCount)
        {
            //至少要有一个线程
            if (threadCount < 1) throw new ArgumentOutOfRangeException("threadCount", "The ProcessQueue class requires at least one worker thread.");
            //同步线程
            lock (syncRoot)
            {
                // 等待队列
                int pending = queue.Count;
                // 创建一个指定最大工作线程数的线程集合，每个线程用来处理排队的项目
                for (int i = threads.Count; i < threadCount; i++) 
                {
                    //注意：在实例化工作线程WorkerThread 时,已经创建了一个ThreadProc 无限循环方法，改方法检测 signalEvent, abortEvent 信号
                    //在收到 abortEvent 时终止并退出，收到 Signal时 循环调用 ProcessItems() 用来处理队列里排队的项目
                    WorkerThread thread = new ProcessQueue<T>.WorkerThread(this);
                    //添加到列表
                    threads.Add(thread);
                    //线程启动
                    thread.Start();
                    //如果队列总有待排项目时
                    if (pending > 1)
                    {
                        //设置信号,让当前工作线程运行（不等待）
                        thread.Signal();
                    }
                    //待排队数减一
                    pending--;
                }

                //如果其它线程调用了SetThreadCount，或者多次调用了 SetThreadCount，从而导致当前实际的线程集合有可能远远大于最大线程数
                //在这种情况下，需要移除多余的线程，从而保证当前threadCount有效
                //移除的线程数 = 当前创建的工作线程集合总数 - 设置的最大线程数
                int toRemove = threads.Count - threadCount;
                if (toRemove > 0)
                {
                    //IsSignaled 如果当前实例收到信号，则为 true；否则为 false
                    //从线程集合里取出正在等待的线程
                    foreach (WorkerThread thread in threads.Where(t => !t.IsSignaled).ToList())
                    {
                        //设置信号使得该线程终止
                        thread.Abort();
                        //从集合中移除改项
                        threads.Remove(thread);
                        //移除数减一
                        toRemove--;
                    }
                    //如果待移除的线程正在运行中
                    //则强制移除该线程直到移除完为止
                    while (toRemove > 0)
                    {
                        WorkerThread thread = threads[threads.Count - 1];
                        thread.Abort();
                        threads.Remove(thread);
                        toRemove--;
                    }
                }
            }
        }

        /// <summary>
        /// 处理队列项
        /// </summary>
        /// <param name="item"></param>
        private void ProcessItem(T item)
        {
            operation(item);
        }

        /// <summary>
        /// 释放时重置线程
        /// </summary>
        private void RegenerateIfDisposed()
        {
            if (isDisposed)
            {
                int threadCount = threads.Count;

                threads.Clear();

                SetThreadCount(threadCount);
            }

            isDisposed = false;
        }
        #endregion

        /// <summary>
        /// 从ProcessQueue清除所有未处理的项目
        /// </summary>
        public void Clear()
        {
            lock (syncRoot)
            {
                queue.Clear();
            }
        }

        /// <summary>
        /// 尝试从ProcessQueue中检索获取下一个项目（如果存在）。 如果不存在，则将值设置为其默认值。
        /// </summary>
        /// <param name="value">如果不存在，则该变量将被设置为默认值.</param>
        /// <returns>如果ProcessQueue包含一个项，则为真，如果没有则为False</returns>
        public bool TryDequeue(out T value)
        {
            lock (syncRoot)
            {
                if (queue.Count > 0)
                {
                    value = queue.Dequeue();

                    return true;
                }
                else
                {
                    value = default(T);

                    return false;
                }
            }
        }

        /// <summary>
        /// 确定队列是否包含指定项
        /// </summary>
        /// <param name="item">当前项</param>
        /// <returns>存在则 True, 不存在则 False</returns>
        public bool Contains(T item)
        {
            lock (syncRoot)
            {
                return queue.Contains(item);
            }
        }

        /// <summary>
        /// 将ProcessQueue的内容复制到外部数组，而不影响ProcessQueue的内容
        /// </summary>
        /// <param name="array">The array to copy the items into</param>
        /// <param name="arrayIndex">The starting index in the array</param>
        public void CopyTo(T[] array, int arrayIndex)
        {
            lock (syncRoot)
            {
                queue.CopyTo(array, arrayIndex);
            }
        }

        /// <summary>
        /// 从ProcessQueue中检索下一个未处理的项目并将其删除
        /// </summary>
        /// <returns>The next unprocessed item in the ProcessQueue</returns>
        public T Dequeue()
        {
            lock (syncRoot)
            {
                return queue.Dequeue();
            }
        }

        /// <summary>
        /// 将一个项目添加到处理队列的末尾
        /// </summary>
        /// <param name="item">添加项</param>
        public void Enqueue(T item)
        {
            lock (syncRoot)
            {
                //新进队列项
                queue.Enqueue(item);
                //当前处理队列正在运行时
                if (isRunning)
                {
                    //清空队列集合重新创建新的线程
                    RegenerateIfDisposed();
                    //取出一个等待的线程
                    WorkerThread firstThread = threads.Where(t => !t.IsSignaled).FirstOrDefault();
                    //存在则运行它
                    if (firstThread != null) firstThread.Signal();
                }
            }
        }

        /// <summary>
        /// 从ProcessQueue中检索下一个未处理的项目，而不删除它
        /// </summary>
        /// <returns>The next unprocessed item in the ProcessQueue</returns>
        public T Peek()
        {
            lock (syncRoot)
            {
                return queue.Peek();
            }
        }

        /// <summary>
        /// 返回一个包含ProcessQueue中所有未处理项目的数组
        /// </summary>
        /// <returns></returns>
        public T[] ToArray()
        {
            lock (syncRoot)
            {
                return queue.ToArray();
            }
        }

        /// <summary>
        /// 将ProcessQueue的容量设置为其包含的项目的实际数量，除非该数量超过当前容量的90％。
        /// </summary>
        public void TrimExcess()
        {
            lock (syncRoot)
            {
                queue.TrimExcess();
            }
        }

        #region IEnumerable<T> Members

        public IEnumerator<T> GetEnumerator()
        {
            return queue.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return queue.GetEnumerator();
        }

        #endregion

        #region ICollection Members

        void ICollection.CopyTo(Array array, int index)
        {
            lock (syncRoot)
            {
                ((ICollection)queue).CopyTo(array, index);
            }
        }

        public int Count
        {
            get
            {
                lock (syncRoot)
                {
                    return queue.Count;
                }
            }
        }

        bool ICollection.IsSynchronized
        {
            get { return true; }
        }

        object ICollection.SyncRoot
        {
            get { return syncRoot; }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            Dispose(true);
        }

        private void Dispose(bool disposing)
        {
            if (disposing)
            {
                foreach (WorkerThread thread in threads) thread.Abort();
            }

            isDisposed = true;
        }

        #endregion

        /// <summary>
        /// 封装.NET Thread对象并管理与控制其行为相关联的WaitHandles
        /// </summary>
        private class WorkerThread
        {
            private ManualResetEvent abortEvent;
            private ManualResetEvent signalEvent;
            private ProcessQueue<T> queue;

            private Thread thread;

            public WorkerThread(ProcessQueue<T> queue)
            {
                abortEvent = new ManualResetEvent(false);
                signalEvent = new ManualResetEvent(false);
                this.queue = queue;

                thread = new Thread(ThreadProc);
                thread.Name = "ProcessQueue Worker ID " + thread.ManagedThreadId;
            }

            /// <summary>
            /// 运行当前线程
            /// </summary>
            public void Start()
            {
                thread.Start();
            }

            /// <summary>
            /// 终止当前线程
            /// </summary>
            public void Abort()
            {
                abortEvent.Set();

                thread.Join();
            }

            /// <summary>
            /// 清除信号WaitHandle，导致线程完成当前的迭代后暂停
            /// </summary>
            public void Pause()
            {
                signalEvent.Reset();
            }

            /// <summary>
            /// 设置信号WaitHandle，等待线程使其恢复运行（如果暂停）
            /// </summary>
            public void Signal()
            {
                signalEvent.Set();
            }

            public bool IsSignaled
            {
                get { return signalEvent.WaitOne(0); }
            }

            /// <summary>
            /// ThreadProc 总线程方法由一个无限循环组成，在发出中止事件时退出
            /// </summary>
            private void ThreadProc()
            {
                WaitHandle[] handles = new WaitHandle[] { signalEvent, abortEvent };

                while (true)
                {
                    //等待指定数组中的任一元素收到信号
                    switch (WaitHandle.WaitAny(handles))
                    {
                        case 0: // signal
                            {
                                ProcessItems();
                            }
                            break;
                        case 1: // abort
                            {
                                return;
                            }
                    }
                }
            }

            /// <summary>
            /// 处理项目
            /// </summary>
            private void ProcessItems()
            {
                T item;
                //从队列中取出一项，这是一个同步的过程
                while (queue.TryDequeue(out item))
                {
                    //处理队列项
                    queue.ProcessItem(item);
                    //如果当前实例收到信号，则为 true；否则为 false。
                    //等待当前队列完成 在 调用 signalEvent.Set() 或者 abortEvent.Set() 时 
                    if (!signalEvent.WaitOne(0) || abortEvent.WaitOne(0)) return;
                }
                //线程状态设置为非终止状态
                signalEvent.Reset();
            }
        }
    }

使用示例：

public void UpLoadFile(TaskFile task)
{
      OnProcessLog("Thread:" + Thread.CurrentThread.ManagedThreadId);
      OnProcessLog("Uploading: " + FTPName + "://" + IP + "/" + task.DIR);
      OnProcessProgress(task, new CompetedEventArgs() { CompetedPrecent = 0, uploadStatus = UploadStatus.Uploading });
      for (int i = 1; i <= 100; i++)
      {
          OnProcessProgress(task, new CompetedEventArgs() { CompetedPrecent = i, uploadStatus = UploadStatus.Uploading });
          Thread.Sleep(GenerateRandomInteger(100,200));
      }
      OnProcessLog("File Uploaded Successfully: " + FTPName + "://" + IP + "/" + task.DIR);
      OnCompleted(task, new CompetedEventArgs() { CompetedPrecent = 0, uploadStatus = UploadStatus.Completed });
}

//模拟
var processQueue = new ProcessQueue<TaskFile>(UpLoadFile);
processQueue.Start();