C# 擴展TaskScheduler實現獨立線程池，支持多任務批量處理，互不干擾，無縫兼容Task

    爲何編寫TaskSchedulerEx類？

    由於.NET默認線程池只有一個線程池，若是某個批量任務一直佔着大量線程，甚至耗盡默認線程池，則會嚴重影響應用程序域中其它任務或批量任務的性能。

     特色：

    一、使用獨立線程池，線程池中線程分爲核心線程和輔助線程，輔助線程會動態增長和釋放，且總線程數不大於參數_maxThreadCount

    二、無縫兼容Task，使用上和Task同樣，能夠用它來實現異步，參見：C# async await 異步執行方法封裝 替代 BackgroundWorker

    三、隊列中還沒有執行的任務能夠取消

    四、經過擴展類TaskHelper實現任務分組

    五、和SmartThreadPool對比，優勢是無縫兼容Task類，和Task類使用沒有區別，由於它自己就是對Task、TaskScheduler的擴展，因此Task類的ContinueWith、WaitAll等方法它都支持，以及兼容async、await異步編程

    六、代碼量至關精簡，TaskSchedulerEx類只有260多行代碼

    七、池中的線程數量會根據負載自動增減，支持，但沒有SmartThreadPool智能，爲了性能，使用了比較笨的方式實現，不知道你們有沒有既智能，性能又高的方案，我有一個思路，在定時器中計算每一個任務執行平均耗時，而後使用公式(線程數 = CPU核心數 * ( 本地計算時間 + 等待時間 ) / 本地計算時間)來計算最佳線程數，而後按最佳線程數來動態建立線程，但這個計算過程可能會犧牲性能

     對比SmartThreadPool：

    TaskSchedulerEx類代碼(使用BlockingCollection，當線程數大於200時，CPU佔用高，線程數小於100時，CPU佔用正常)：

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

namespace Utils
{
    public class TaskSchedulerEx : TaskScheduler, IDisposable
    {
        #region 外部方法
        [DllImport("kernel32.dll", EntryPoint = "SetProcessWorkingSetSize")]
        public static extern int SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);
        #endregion

        #region 變量屬性事件
        private BlockingCollection<Task> _tasks = new BlockingCollection<Task>();
        List<Thread> _threadList = new List<Thread>();
        private int _threadCount = 0;
        private int _maxThreadCount = 0;
        private int _timeOut = Timeout.Infinite;
        private int _extTimeOut = 3000;
        private Task _tempTask;
        private int _activeThreadCount = 0;
        private System.Timers.Timer _timer;
        private object _lockCreateTimer = new object();

        /// <summary>
        /// 活躍線程數
        /// </summary>
        public int ActiveThreadCount
        {
            get { return _activeThreadCount; }
        }

        /// <summary>
        /// 核心線程數
        /// </summary>
        public int CoreThreadCount
        {
            get { return _threadCount; }
        }

        /// <summary>
        /// 最大線程數
        /// </summary>
        public int MaxThreadCount
        {
            get { return _maxThreadCount; }
        }
        #endregion

        #region 構造函數
        public TaskSchedulerEx(int threadCount = 10, int maxThreadCount = 20)
        {
            _maxThreadCount = maxThreadCount;
            CreateThreads(threadCount);
        }
        #endregion

        #region override GetScheduledTasks
        protected override IEnumerable<Task> GetScheduledTasks()
        {
            return _tasks;
        }
        #endregion

        #region override TryExecuteTaskInline
        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            return false;
        }
        #endregion

        #region override QueueTask
        protected override void QueueTask(Task task)
        {
            _tasks.Add(task);
        }
        #endregion

        #region 資源釋放
        /// <summary>
        /// 資源釋放
        /// 若是尚有任務在執行，則會在調用此方法的線程上引起System.Threading.ThreadAbortException，請使用Task.WaitAll等待任務執行完畢後，再調用該方法
        /// </summary>
        public void Dispose()
        {
            if (_timer != null)
            {
                _timer.Stop();
                _timer.Dispose();
                _timer = null;
            }

            _timeOut = 100;

            foreach (Thread item in _threadList)
            {
                item.Abort();
                Interlocked.Decrement(ref _activeThreadCount);
            }
            _threadList.Clear();

            GC.Collect();
            GC.WaitForPendingFinalizers();
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
            }
        }
        #endregion

        #region 建立線程池
        /// <summary>
        /// 建立線程池
        /// </summary>
        private void CreateThreads(int? threadCount = null)
        {
            if (threadCount != null) _threadCount = threadCount.Value;
            _timeOut = Timeout.Infinite;

            for (int i = 0; i < _threadCount; i++)
            {
                Interlocked.Increment(ref _activeThreadCount);
                Thread thread = new Thread(new ThreadStart(() =>
                {
                    Task task;
                    while (_tasks.TryTake(out task, _timeOut))
                    {
                        CreateTimer();
                        TryExecuteTask(task);
                    }
                }));
                thread.IsBackground = true;
                thread.Start();
                _threadList.Add(thread);
            }
        }
        #endregion

        #region 建立線程
        /// <summary>
        /// 建立線程
        /// </summary>
        private void CreateThread()
        {
            Interlocked.Increment(ref _activeThreadCount);
            Thread thread = null;
            thread = new Thread(new ThreadStart(() =>
            {
                Task task;
                while (_tasks.TryTake(out task, _extTimeOut))
                {
                    TryExecuteTask(task);
                }
                Interlocked.Decrement(ref _activeThreadCount);
                if (_activeThreadCount == _threadCount)
                {
                    GC.Collect();
                    GC.WaitForPendingFinalizers();
                    if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                    {
                        SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
                    }
                }
                if (thread != null)
                {
                    thread.Abort();
                    thread = null;
                }
            }));
            thread.IsBackground = true;
            thread.Start();
        }
        #endregion

        #region 建立定時器
        private void CreateTimer()
        {
            if (_timer == null) //_timer不爲空時，跳過，不走lock，提高性能
            {
                lock (_lockCreateTimer)
                {
                    if (_timer == null)
                    {
                        int interval = 20;
                        _timer = new System.Timers.Timer();
                        _timer.Interval = 1000;
                        _timer.Elapsed += (s, e) =>
                        {
                            if (_timer.Interval != interval) _timer.Interval = interval;

                            if (_activeThreadCount >= _threadCount && _activeThreadCount < _maxThreadCount)
                            {
                                if (_tasks.Count > 0)
                                {
                                    CreateThread();
                                }
                                else
                                {
                                    if (_timer != null)
                                    {
                                        _timer.Stop();
                                        _timer.Dispose();
                                        _timer = null;
                                    }
                                }
                            }
                        };
                        _timer.Start();
                    }
                }
            }
        }
        #endregion

        #region 所有取消
        /// <summary>
        /// 所有取消
        /// 當前正在執行的任務沒法取消，取消的只是後續任務，至關於AbortAll
        /// </summary>
        public void CancelAll()
        {
            while (_tasks.TryTake(out _tempTask)) { }
        }
        #endregion

    }
}

View Code

    TaskSchedulerEx類代碼(使用ConcurrentQueue，測試500個線程，CPU佔用0%-2%，正常)：

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

namespace Utils
{
    /// <summary>
    /// TaskScheduler擴展
    /// 每一個實例都是獨立線程池
    /// </summary>
    public class TaskSchedulerEx : TaskScheduler, IDisposable
    {
        #region 外部方法
        [DllImport("kernel32.dll", EntryPoint = "SetProcessWorkingSetSize")]
        public static extern int SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);
        #endregion

        #region 變量屬性事件
        private ConcurrentQueue<Task> _tasks = new ConcurrentQueue<Task>();
        List<Thread> _coreThreadList = new List<Thread>();
        private int _coreThreadCount = 0;
        private int _maxThreadCount = 0;
        private int _auxiliaryThreadTimeOut = 20000; //輔助線程釋放時間
        private int _activeThreadCount = 0;
        private System.Timers.Timer _timer;
        private object _lockCreateTimer = new object();
        private bool _run = true;

        /// <summary>
        /// 活躍線程數
        /// </summary>
        public int ActiveThreadCount
        {
            get { return _activeThreadCount; }
        }

        /// <summary>
        /// 核心線程數
        /// </summary>
        public int CoreThreadCount
        {
            get { return _coreThreadCount; }
        }

        /// <summary>
        /// 最大線程數
        /// </summary>
        public int MaxThreadCount
        {
            get { return _maxThreadCount; }
        }
        #endregion

        #region 構造函數
        /// <summary>
        /// TaskScheduler擴展
        /// 每一個實例都是獨立線程池
        /// </summary>
        /// <param name="coreThreadCount">核心線程數(大於或等於0，不宜過大)(若是是一次性使用，則設置爲0比較合適)</param>
        /// <param name="maxThreadCount">最大線程數</param>
        public TaskSchedulerEx(int coreThreadCount = 10, int maxThreadCount = 20)
        {
            _maxThreadCount = maxThreadCount;
            CreateCoreThreads(coreThreadCount);
        }
        #endregion

        #region override GetScheduledTasks
        protected override IEnumerable<Task> GetScheduledTasks()
        {
            return _tasks;
        }
        #endregion

        #region override TryExecuteTaskInline
        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            return false;
        }
        #endregion

        #region override QueueTask
        protected override void QueueTask(Task task)
        {
            CreateTimer();
            _tasks.Enqueue(task);
        }
        #endregion

        #region 資源釋放
        /// <summary>
        /// 資源釋放
        /// 若是尚有任務在執行，則會在調用此方法的線程上引起System.Threading.ThreadAbortException，請使用Task.WaitAll等待任務執行完畢後，再調用該方法
        /// </summary>
        public void Dispose()
        {
            _run = false;

            if (_timer != null)
            {
                _timer.Stop();
                _timer.Dispose();
                _timer = null;
            }

            foreach (Thread item in _coreThreadList)
            {
                item.Abort();
                Interlocked.Decrement(ref _activeThreadCount);
            }
            _coreThreadList.Clear();

            GC.Collect();
            GC.WaitForPendingFinalizers();
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
            }
        }
        #endregion

        #region 建立核心線程池
        /// <summary>
        /// 建立核心線程池
        /// </summary>
        private void CreateCoreThreads(int? coreThreadCount = null)
        {
            if (coreThreadCount != null) _coreThreadCount = coreThreadCount.Value;

            for (int i = 0; i < _coreThreadCount; i++)
            {
                Interlocked.Increment(ref _activeThreadCount);
                Thread thread = new Thread(new ThreadStart(() =>
                {
                    Task task;
                    while (_run)
                    {
                        if (_tasks.TryDequeue(out task))
                        {
                            TryExecuteTask(task);
                        }
                        else
                        {
                            Thread.Sleep(10);
                        }
                    }
                }));
                thread.IsBackground = true;
                thread.Start();
                _coreThreadList.Add(thread);
            }
        }
        #endregion

        #region 建立輔助線程
        /// <summary>
        /// 建立輔助線程
        /// </summary>
        private void CreateThread()
        {
            Interlocked.Increment(ref _activeThreadCount);
            Thread thread = null;
            thread = new Thread(new ThreadStart(() =>
            {
                Task task;
                DateTime dt = DateTime.Now;
                while (_run && DateTime.Now.Subtract(dt).TotalMilliseconds < _auxiliaryThreadTimeOut)
                {
                    if (_tasks.TryDequeue(out task))
                    {
                        TryExecuteTask(task);
                        dt = DateTime.Now;
                    }
                    else
                    {
                        Thread.Sleep(100);
                    }
                }
                Interlocked.Decrement(ref _activeThreadCount);
                if (_activeThreadCount == _coreThreadCount)
                {
                    GC.Collect();
                    GC.WaitForPendingFinalizers();
                    if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                    {
                        SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
                    }
                }
                if (thread != null)
                {
                    thread.Abort();
                    thread = null;
                }
            }));
            thread.IsBackground = true;
            thread.Start();
        }
        #endregion

        #region 建立定時器
        private void CreateTimer()
        {
            if (_timer == null) //_timer不爲空時，跳過，不走lock，提高性能
            {
                lock (_lockCreateTimer)
                {
                    if (_timer == null)
                    {
                        int interval = 20;
                        _timer = new System.Timers.Timer();
                        _timer.Interval = _coreThreadCount == 0 ? 1 : 500;
                        _timer.Elapsed += (s, e) =>
                        {
                            if (_timer.Interval != interval) _timer.Interval = interval;

                            if (_activeThreadCount >= _coreThreadCount && _activeThreadCount < _maxThreadCount)
                            {
                                if (_tasks.Count > 0)
                                {
                                    CreateThread();
                                }
                                else
                                {
                                    if (_timer != null)
                                    {
                                        _timer.Stop();
                                        _timer.Dispose();
                                        _timer = null;
                                    }
                                }
                            }
                        };
                        _timer.Start();
                    }
                }
            }
        }
        #endregion

        #region 所有取消
        /// <summary>
        /// 所有取消
        /// 當前正在執行的任務沒法取消，取消的只是後續任務，至關於AbortAll
        /// </summary>
        public void CancelAll()
        {
            Task tempTask;
            while (_tasks.TryDequeue(out tempTask)) { }
        }
        #endregion

    }
}

View Code

    RunHelper類代碼：

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

namespace Utils
{
    /// <summary>
    /// 線程工具類
    /// </summary>
    public static class RunHelper
    {
        #region 變量屬性事件

        #endregion

        #region 線程中執行
        /// <summary>
        /// 線程中執行
        /// </summary>
        public static Task Run(this TaskScheduler scheduler, Action<object> doWork, object arg = null, Action<Exception> errorAction = null)
        {
            return Task.Factory.StartNew((obj) =>
            {
                try
                {
                    doWork(obj);
                }
                catch (Exception ex)
                {
                    if (errorAction != null) errorAction(ex);
                    LogUtil.Error(ex, "ThreadUtil.Run錯誤");
                }
            }, arg, CancellationToken.None, TaskCreationOptions.None, scheduler);
        }
        #endregion

        #region 線程中執行
        /// <summary>
        /// 線程中執行
        /// </summary>
        public static Task Run(this TaskScheduler scheduler, Action doWork, Action<Exception> errorAction = null)
        {
            return Task.Factory.StartNew(() =>
            {
                try
                {
                    doWork();
                }
                catch (Exception ex)
                {
                    if (errorAction != null) errorAction(ex);
                    LogUtil.Error(ex, "ThreadUtil.Run錯誤");
                }
            }, CancellationToken.None, TaskCreationOptions.None, scheduler);
        }
        #endregion

        #region 線程中執行
        /// <summary>
        /// 線程中執行
        /// </summary>
        public static Task<T> Run<T>(this TaskScheduler scheduler, Func<object, T> doWork, object arg = null, Action<Exception> errorAction = null)
        {
            return Task.Factory.StartNew<T>((obj) =>
            {
                try
                {
                    return doWork(obj);
                }
                catch (Exception ex)
                {
                    if (errorAction != null) errorAction(ex);
                    LogUtil.Error(ex, "ThreadUtil.Run錯誤");
                    return default(T);
                }
            }, arg, CancellationToken.None, TaskCreationOptions.None, scheduler);
        }
        #endregion

        #region 線程中執行
        /// <summary>
        /// 線程中執行
        /// </summary>
        public static Task<T> Run<T>(this TaskScheduler scheduler, Func<T> doWork, Action<Exception> errorAction = null)
        {
            return Task.Factory.StartNew<T>(() =>
            {
                try
                {
                    return doWork();
                }
                catch (Exception ex)
                {
                    if (errorAction != null) errorAction(ex);
                    LogUtil.Error(ex, "ThreadUtil.Run錯誤");
                    return default(T);
                }
            }, CancellationToken.None, TaskCreationOptions.None, scheduler);
        }
        #endregion

        #region 線程中執行
        /// <summary>
        /// 線程中執行
        /// </summary>
        public static async Task<T> RunAsync<T>(this TaskScheduler scheduler, Func<object, T> doWork, object arg = null, Action<Exception> errorAction = null)
        {
            return await Task.Factory.StartNew<T>((obj) =>
            {
                try
                {
                    return doWork(obj);
                }
                catch (Exception ex)
                {
                    if (errorAction != null) errorAction(ex);
                    LogUtil.Error(ex, "ThreadUtil.Run錯誤");
                    return default(T);
                }
            }, arg, CancellationToken.None, TaskCreationOptions.None, scheduler);
        }
        #endregion

        #region 線程中執行
        /// <summary>
        /// 線程中執行
        /// </summary>
        public static async Task<T> RunAsync<T>(this TaskScheduler scheduler, Func<T> doWork, Action<Exception> errorAction = null)
        {
            return await Task.Factory.StartNew<T>(() =>
            {
                try
                {
                    return doWork();
                }
                catch (Exception ex)
                {
                    if (errorAction != null) errorAction(ex);
                    LogUtil.Error(ex, "ThreadUtil.Run錯誤");
                    return default(T);
                }
            }, CancellationToken.None, TaskCreationOptions.None, scheduler);
        }
        #endregion

    }
}

View Code

    TaskHelper擴展類(代碼中LimitedTaskScheduler改成TaskSchedulerEx便可)(這個任務分類有點多，每一個任務分類的核心線程通常是不釋放的，一直佔着線程，算不算濫用)：

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

namespace Utils
{
    /// <summary>
    /// Task幫助類基類
    /// </summary>
    public class TaskHelper
    {
        #region UI任務
        private static LimitedTaskScheduler _UITask;
        /// <summary>
        /// UI任務(4個線程)
        /// </summary>
        public static LimitedTaskScheduler UITask
        {
            get
            {
                if (_UITask == null) _UITask = new LimitedTaskScheduler(4);
                return _UITask;
            }
        }
        #endregion

        #region 菜單任務
        private static LimitedTaskScheduler _MenuTask;
        /// <summary>
        /// 菜單任務
        /// </summary>
        public static LimitedTaskScheduler MenuTask
        {
            get
            {
                if (_MenuTask == null) _MenuTask = new LimitedTaskScheduler(2);
                return _MenuTask;
            }
        }
        #endregion

        #region 計算任務
        private static LimitedTaskScheduler _CalcTask;
        /// <summary>
        /// 計算任務(8個線程)
        /// </summary>
        public static LimitedTaskScheduler CalcTask
        {
            get
            {
                if (_CalcTask == null) _CalcTask = new LimitedTaskScheduler(8);
                return _CalcTask;
            }
        }
        #endregion

        #region 網絡請求
        private static LimitedTaskScheduler _RequestTask;
        /// <summary>
        /// 網絡請求(32個線程)
        /// </summary>
        public static LimitedTaskScheduler RequestTask
        {
            get
            {
                if (_RequestTask == null) _RequestTask = new LimitedTaskScheduler(32);
                return _RequestTask;
            }
        }
        #endregion

        #region 數據庫任務
        private static LimitedTaskScheduler _DBTask;
        /// <summary>
        /// 數據庫任務(32個線程)
        /// </summary>
        public static LimitedTaskScheduler DBTask
        {
            get
            {
                if (_DBTask == null) _DBTask = new LimitedTaskScheduler(32);
                return _DBTask;
            }
        }
        #endregion

        #region IO任務
        private static LimitedTaskScheduler _IOTask;
        /// <summary>
        /// IO任務(8個線程)
        /// </summary>
        public static LimitedTaskScheduler IOTask
        {
            get
            {
                if (_IOTask == null) _IOTask = new LimitedTaskScheduler(8);
                return _IOTask;
            }
        }
        #endregion

        #region 首頁任務
        private static LimitedTaskScheduler _MainPageTask;
        /// <summary>
        /// 首頁任務(16個線程)
        /// </summary>
        public static LimitedTaskScheduler MainPageTask
        {
            get
            {
                if (_MainPageTask == null) _MainPageTask = new LimitedTaskScheduler(16);
                return _MainPageTask;
            }
        }
        #endregion

        #region 圖片加載任務
        private static LimitedTaskScheduler _LoadImageTask;
        /// <summary>
        /// 圖片加載任務(32個線程)
        /// </summary>
        public static LimitedTaskScheduler LoadImageTask
        {
            get
            {
                if (_LoadImageTask == null) _LoadImageTask = new LimitedTaskScheduler(32);
                return _LoadImageTask;
            }
        }
        #endregion

        #region 瀏覽器任務
        private static LimitedTaskScheduler _BrowserTask;
        /// <summary>
        /// 瀏覽器任務
        /// </summary>
        public static LimitedTaskScheduler BrowserTask
        {
            get
            {
                if (_BrowserTask == null) _BrowserTask = new LimitedTaskScheduler(2);
                return _BrowserTask;
            }
        }
        #endregion

    }
}

View Code

     Form1.cs測試代碼：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Management;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Utils;

namespace test
{
    public partial class Form1 : Form
    {
        private TaskSchedulerEx _taskSchedulerEx = null;
        private TaskSchedulerEx _taskSchedulerExSmall = null;
        private TaskSchedulerEx _task = null;

        public Form1()
        {
            InitializeComponent();
            _taskSchedulerEx = new TaskSchedulerEx(50, 500);
            _taskSchedulerExSmall = new TaskSchedulerEx(5, 50);
            _task = new TaskSchedulerEx(2, 10);
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// 模擬大量網絡請求任務
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            DoTask(_taskSchedulerEx, 200000, 1000, 20);
        }

        /// <summary>
        /// 模擬CPU密集型任務
        /// </summary>
        private void button2_Click(object sender, EventArgs e)
        {
            DoTask(_taskSchedulerEx, 100000, 2000, 1);
        }

        /// <summary>
        /// 模擬大量網絡請求任務
        /// </summary>
        private void button3_Click(object sender, EventArgs e)
        {
            DoTask(_taskSchedulerExSmall, 2000, 100, 20);
        }

        /// <summary>
        /// 模擬CPU密集型任務
        /// </summary>
        private void button4_Click(object sender, EventArgs e)
        {
            DoTask(_taskSchedulerExSmall, 2000, 100, 1);
        }

        /// <summary>
        /// 模擬任務
        /// </summary>
        /// <param name="scheduler">scheduler</param>
        /// <param name="taskCount">任務數量</param>
        /// <param name="logCount">每隔多少條數據打一個日誌</param>
        /// <param name="delay">模擬延遲或耗時(毫秒)</param>
        private void DoTask(TaskSchedulerEx scheduler, int taskCount, int logCount, int delay)
        {
            _task.Run(() =>
            {
                Log("開始");
                DateTime dt = DateTime.Now;
                List<Task> taskList = new List<Task>();
                for (int i = 1; i <= taskCount; i++)
                {
                    Task task = scheduler.Run((obj) =>
                    {
                        var k = (int)obj;
                        Thread.Sleep(delay); //模擬延遲或耗時
                        if (k % logCount == 0)
                        {
                            Log("最大線程數：" + scheduler.MaxThreadCount + " 核心線程數：" + scheduler.CoreThreadCount + " 活躍線程數：" + scheduler.ActiveThreadCount.ToString().PadLeft(4, ' ') + " 處理數/總數：" + k + " / " + taskCount);
                        }
                    }, i, (ex) =>
                    {
                        Log(ex.Message);
                    });
                    taskList.Add(task);
                }
                Task.WaitAll(taskList.ToArray());
                double d = DateTime.Now.Subtract(dt).TotalSeconds;
                Log("完成，耗時：" + d + "秒");
            });
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            if (_taskSchedulerEx != null)
            {
                _taskSchedulerEx.Dispose(); //釋放資源
                _taskSchedulerEx = null;
            }
        }
    }
}

View Code

     測試截圖：