/// <summary>
    /// 隊列多線程,T 代表處理的單個類型~
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class QueueThreadBase<T>
    {
        #region 變量&屬性
        /// <summary>
        /// 待處理結果
        /// </summary>
        private class PendingResult
        {
            /// <summary>
            /// 待處理值
            /// </summary>
            public T PendingValue { get; set; }
            /// <summary>
            /// 是否有值
            /// </summary>
            public bool IsHad { get; set; }
        }
        /// <summary>
        /// 線程數
        /// </summary>
        public int ThreadCount
        {
            get { return this.m_ThreadCount; }
            set { this.m_ThreadCount = value; }
        }
        private int m_ThreadCount = 5;
        /// <summary>
        /// 取消=True
        /// </summary>
        public bool Cancel { get; set; }
        /// <summary>
        /// 線程列表
        /// </summary>
        List<Thread> m_ThreadList;
        /// <summary>
        /// 完成隊列個數
        /// </summary>
        private volatile int m_CompletedCount = 0;
        /// <summary>
        /// 隊列總數
        /// </summary>
        private int m_QueueCount = 0;
        /// <summary>
        /// 全部完成鎖
        /// </summary>
        private object m_AllCompletedLock = new object();
        /// <summary>
        /// 完成的線程數
        /// </summary>
        private int m_CompetedCount = 0;
        /// <summary>
        /// 隊列鎖
        /// </summary>
        private object m_PendingQueueLock = new object();
        private Queue<T> m_InnerQueue;
        #endregion

        #region 事件相關
        /// <summary>
        /// 全部完成事件
        /// </summary>
        public event Action<CompetedEventArgs> AllCompleted;
        /// <summary>
        /// 單個完成事件
        /// </summary>
        public event Action<T, CompetedEventArgs> OneCompleted;
        /// <summary>
        /// 引發全部完成事件
        /// </summary>
        /// <param name="args"></param>
        private void OnAllCompleted(CompetedEventArgs args)
        {
            if (AllCompleted != null)
            {
                try
                {
                    AllCompleted(args);//全部完成事件
                }
                catch { }
            }
        }
        /// <summary>
        /// 引發單個完成事件
        /// </summary>
        /// <param name="pendingValue"></param>
        /// <param name="args"></param>
        private void OnOneCompleted(T pendingValue, CompetedEventArgs args)
        {
            if (OneCompleted != null)
            {
                try
                {
                    OneCompleted(pendingValue, args);
                }
                catch { }

            }
        }
        #endregion

        #region 構造
        public QueueThreadBase(IEnumerable<T> collection)
        {
            m_InnerQueue = new Queue<T>(collection);
            this.m_QueueCount = m_InnerQueue.Count;
        }

        #endregion

        #region 主體
        /// <summary>
        /// 初始化線程
        /// </summary>
        private void InitThread()
        {
            m_ThreadList = new List<Thread>();
            for (int i = 0; i < ThreadCount; i++)
            {
                Thread t = new Thread(new ThreadStart(InnerDoWork));
        m_ThreadList.Add(t);
                t.IsBackground = true;
                t.Start();
            }
        }
        /// <summary>
        /// 開始
        /// </summary>
        public void Start()
        {
            InitThread();
        }
        /// <summary>
        /// 線程工作
        /// </summary>
        private void InnerDoWork()
        {
            try
            {
                Exception doWorkEx = null;
                DoWorkResult doworkResult = DoWorkResult.ContinueThread;
                var t = CurrentPendingQueue;
                while (!this.Cancel && t.IsHad)
                {
                    try
                    {
                        doworkResult = DoWork(t.PendingValue);
                    }
                    catch (Exception ex)
                    {
                        doWorkEx = ex;
                    }
                    m_CompletedCount++;
                    int precent = m_CompletedCount * 100 / m_QueueCount;
                    OnOneCompleted(t.PendingValue, new CompetedEventArgs() { CompetedPrecent = precent, InnerException = doWorkEx });
                    if (doworkResult == DoWorkResult.AbortAllThread)
                    {
                        this.Cancel = true;
                        break;
                    }
                    else if (doworkResult == DoWorkResult.AbortCurrentThread)
                    {
                        break;
                    }
                    t = CurrentPendingQueue;
                }

                lock (m_AllCompletedLock)
                {
                    m_CompetedCount++;
                    if (m_CompetedCount == m_ThreadList.Count)
                    {
                        OnAllCompleted(new CompetedEventArgs() { CompetedPrecent = 100 });
                    }
                }

            }
            catch
            {
                throw;
            }
        }
        /// <summary>
        /// 子類重寫
        /// </summary>
        /// <param name="pendingValue"></param>
        /// <returns></returns>
        protected virtual DoWorkResult DoWork(T pendingValue)
        {
            return DoWorkResult.ContinueThread;
        }
        /// <summary>
        /// 獲取當前結果
        /// </summary>
        private PendingResult CurrentPendingQueue
        {
            get
            {
                lock (m_PendingQueueLock)
                {
                    PendingResult t = new PendingResult();
                    if (m_InnerQueue.Count != 0)
                    {
                        t.PendingValue = m_InnerQueue.Dequeue();
                        t.IsHad = true;
                    }
                    else
                    {
                        t.PendingValue = default(T);
                        t.IsHad = false;
                    }
                    return t;
                }
            }
        }

        #endregion

        #region 相關類&枚舉
        /// <summary>
        /// dowork結果枚舉
        /// </summary>
        public enum DoWorkResult
        {
            /// <summary>
            /// 繼續運行，默認
            /// </summary>
            ContinueThread = 0,
            /// <summary>
            /// 終止當前線程
            /// </summary>
            AbortCurrentThread = 1,
            /// <summary>
            /// 終止全部線程
            /// </summary>
            AbortAllThread = 2
        }
        /// <summary>
        /// 完成事件數據
        /// </summary>
        public class CompetedEventArgs : EventArgs
        {
            public CompetedEventArgs()
            {

            }
            /// <summary>
            /// 完成百分率
            /// </summary>
            public int CompetedPrecent { get; set; }
            /// <summary>
            /// 異常信息
            /// </summary>
            public Exception InnerException { get; set; }
        }
        #endregion

    }

public QueueThreadBase(IEnumerable<T> collection)

/// <summary>
        /// 取消=True
        /// </summary>
        public bool Cancel { get; set; }

/// <summary>
        /// 線程數
        /// </summary>
        public int ThreadCount
        {
            get { return this.m_ThreadCount; }
            set { this.m_ThreadCount = value; }
        }

/// <summary>
        /// 全部完成事件
        /// </summary>
        public event Action<CompetedEventArgs> AllCompleted;
        /// <summary>
        /// 單個完成事件
        /// </summary>
        public event Action<T, CompetedEventArgs> OneCompleted;

/// <summary>
        /// 完成事件數據
        /// </summary>
        public class CompetedEventArgs : EventArgs
        {
            public CompetedEventArgs()
            {

            }
            /// <summary>
            /// 完成百分率
            /// </summary>
            public int CompetedPrecent { get; set; }
            /// <summary>
            /// 異常信息
            /// </summary>
            public Exception InnerException { get; set; }
        }

/// <summary>
        /// dowork結果枚舉
        /// </summary>
        public enum DoWorkResult
        {
            /// <summary>
            /// 繼續運行，默認
            /// </summary>
            ContinueThread = 0,
            /// <summary>
            /// 終止當前線程
            /// </summary>
            AbortCurrentThread = 1,
            /// <summary>
            /// 終止全部線程
            /// </summary>
            AbortAllThread = 2
        }

/// <summary>
    /// 下載線程對了.
    /// </summary>
    public class DownLoadQueueThread:QueueThreadBase<int>
    {
        /// <summary>
        ///
        /// </summary>
        /// <param name="list">下載的列表ID</param>
        public DownLoadQueueThread(IEnumerable<int> list):base(list)
        {

        }
        /// <summary>
        /// 每次多線程都到這里來,處理多線程
        /// </summary>
        /// <param name="pendingValue"列表ID></param>
        /// <returns></returns>
        protected override DoWorkResult DoWork(int pendingID)
        {
            try
            {

                //..........多線程處理....
                return DoWorkResult.ContinueThread;//沒有異常讓線程繼續跑..

            }
            catch (Exception)
            {

                return DoWorkResult.AbortCurrentThread;//有異常,可以終止當前線程.當然.也可以繼續,
                //return  DoWorkResult.AbortAllThread; //特殊情況下 ,有異常終止所有的線程...
            }

            //return base.DoWork(pendingValue);
        }
    }

用法