Task.Factory.StartNew 测试

到底该用多少线程？线程数、CPU核心数、本地计算时间、等待时间的关系 线程数 = CPU核心数 * ( 本地计算时间 + 等待时间 ) / 本地计算时间

下面是Task.Factory.StartNew和自己写的TaskHelper.LargeTask.Run对比测试

一、Task.Factory.StartNew 使用 TaskCreationOptions.LongRunning 参数

代码：

private int n = 50000; //问题规模
private int t = 25; //等待时间
private int pageSize = 1000; //打印分页

private void TestTaskStartNew()
{
    Task.Factory.StartNew(() =>
    {
        Stopwatch stopwatch = Stopwatch.StartNew();

        List<Task> taskList = new List<Task>();
        for (int i = 0; i <= n; i++)
        {
            Task task = Task.Factory.StartNew((obj) =>
            {
                Thread.Sleep(t); //等待时间

                int index = (int)obj;
                if (index % pageSize == 0)
                {
                    this.TryInvoke2(() =>
                    {
                        textBox1.AppendText(index.ToString() + "  ");
                    });
                }
            }, i, TaskCreationOptions.LongRunning);
            taskList.Add(task);
        }
        Task.WaitAll(taskList.ToArray());

        this.TryInvoke2(() =>
        {
            textBox1.AppendText(string.Format("
【Task.Factory.StartNew 问题规模:{0} 等待时间:{1} 耗时：{2}秒】
", n, t, stopwatch.Elapsed.TotalSeconds));
        });
    });
}

private void TestTaskHelper()
{
    Task.Factory.StartNew(() =>
    {
        Stopwatch stopwatch = Stopwatch.StartNew();

        List<Task> taskList = new List<Task>();
        for (int i = 0; i <= n; i++)
        {
            Task task = TaskHelper.LargeTask.Run((obj) =>
            {
                Thread.Sleep(t); //等待时间

                int index = (int)obj;
                if (index % pageSize == 0)
                {
                    this.TryInvoke2(() =>
                    {
                        textBox1.AppendText(index.ToString() + "  ");
                    });
                }
            }, i);
            taskList.Add(task);
        }
        Task.WaitAll(taskList.ToArray());

        this.TryInvoke2(() =>
        {
            textBox1.AppendText(string.Format("
【TaskHelper.LargeTask.Run {3}线程 问题规模:{0} 等待时间:{1} 耗时：{2}秒】
", n, t, stopwatch.Elapsed.TotalSeconds, TaskHelper.LargeTask.ThreadCount));
        });
    });
}

测试结果：

0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000 11000 12000 13000 14000 15000 16000 17000 18000 19000 20000 21000 22000 23000 24000 25000 26000 27000 28000 29000 30000 31000 32000 33000 34000 35000 36000 37000 38000 39000 40000 41000 42000 43000 44000 45000 46000 47000 48000 49000 50000
【TaskHelper.LargeTask.Run 128线程 问题规模:50000 等待时间:25 耗时：10.5975181秒】
0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000 11000 12000 13000 14000 15000 16000 17000 18000 19000 20000 21000 22000 23000 24000 25000 26000 27000 28000 29000 30000 31000 32000 33000 34000 35000 36000 37000 38000 39000 40000 41000 42000 43000 44000 45000 46000 47000 48000 49000 50000
【Task.Factory.StartNew 问题规模:50000 等待时间:25 耗时：8.2380754秒】
0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000 11000 12000 13000 14000 15000 16000 17000 18000 19000 20000 21000 22000 23000 24000 25000 26000 27000 28000 29000 30000 31000 32000 33000 34000 35000 36000 37000 38000 39000 40000 41000 42000 43000 44000 45000 46000 47000 48000 49000 50000
【TaskHelper.LargeTask.Run 128线程 问题规模:50000 等待时间:25 耗时：10.4376939秒】
0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000 11000 12000 13000 14000 15000 16000 17000 18000 19000 20000 21000 22000 23000 24000 25000 26000 27000 28000 29000 30000 31000 32000 33000 34000 35000 36000 37000 38000 39000 40000 41000 42000 43000 44000 45000 46000 47000 48000 49000 50000
【Task.Factory.StartNew 问题规模:50000 等待时间:25 耗时：9.2322552秒】

测试结果说明：

我的电脑的CPU是i5-8265U，4核8线程
根据等待时间设置合适的线程数对TaskHelper.LargeTask.Run有利
使用TaskHelper.LargeTask.Run运行时的CPU占用在5%以下，创建128个线程的瞬间CPU占用达到30%，使用Task.Factory.StartNew运行时的CPU占用接近100%
资源释放情况：Task.Factory.StartNew使用TaskCreationOptions.LongRunning参数运行完成后线程数立即释放，句柄数未立即释放，而TaskHelper.LargeTask.Run提供了手动释放的方法可以立即释放线程数和句柄数，但需要手动调用才能释放

 二、Task.Factory.StartNew 不使用 TaskCreationOptions.LongRunning 参数

代码：

private int n = 2000; //问题规模
private int t = 100; //等待时间
private int pageSize = 100; //打印分页

private void TestTaskStartNew()
{
    Task.Factory.StartNew(() =>
    {
        Stopwatch stopwatch = Stopwatch.StartNew();

        List<Task> taskList = new List<Task>();
        for (int i = 0; i <= n; i++)
        {
            Task task = Task.Factory.StartNew((obj) =>
            {
                Thread.Sleep(t); //等待时间

                int index = (int)obj;
                if (index % pageSize == 0)
                {
                    this.TryInvoke2(() =>
                    {
                        textBox1.AppendText(index.ToString() + "  ");
                    });
                }
            }, i);
            taskList.Add(task);
        }
        Task.WaitAll(taskList.ToArray());

        this.TryInvoke2(() =>
        {
            textBox1.AppendText(string.Format("
【Task.Factory.StartNew 问题规模:{0} 等待时间:{1} 耗时：{2}秒】
", n, t, stopwatch.Elapsed.TotalSeconds));
        });
    });
}

private void TestTaskHelper()
{
    Task.Factory.StartNew(() =>
    {
        Stopwatch stopwatch = Stopwatch.StartNew();

        List<Task> taskList = new List<Task>();
        for (int i = 0; i <= n; i++)
        {
            Task task = TaskHelper.LargeTask.Run((obj) =>
            {
                Thread.Sleep(t); //等待时间

                int index = (int)obj;
                if (index % pageSize == 0)
                {
                    this.TryInvoke2(() =>
                    {
                        textBox1.AppendText(index.ToString() + "  ");
                    });
                }
            }, i);
            taskList.Add(task);
        }
        Task.WaitAll(taskList.ToArray());

        this.TryInvoke2(() =>
        {
            textBox1.AppendText(string.Format("
【TaskHelper.LargeTask.Run {3}线程 问题规模:{0} 等待时间:{1} 耗时：{2}秒】
", n, t, stopwatch.Elapsed.TotalSeconds, TaskHelper.LargeTask.ThreadCount));
        });
    });
}

测试结果：

0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000
【TaskHelper.LargeTask.Run 96线程 问题规模:2000 等待时间:100 耗时：2.1529565秒】
0 2000 100 200 300 400 500 600 700 800 900 1900 1000 1100 1200 1300 1400 1500 1600 1700 1800
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：17.309869秒】
0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000
【TaskHelper.LargeTask.Run 96线程 问题规模:2000 等待时间:100 耗时：2.143763秒】
0 2000 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：8.8674353秒】
0 2000 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：6.5490833秒】
0 2000 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：5.1381533秒】
0 2000 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：4.434294秒】
0 2000 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：4.329009秒】
2000 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：3.6231239秒】
2000 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900
【Task.Factory.StartNew 问题规模:2000 等待时间:100 耗时：3.6303149秒】

测试结论：

Task.Factory.StartNew在不使用TaskCreationOptions.LongRunning参数时，运行大量耗时任务，线程数增加缓慢，导致需要花费很长时间，如果线程池耗尽，或者线程池未耗尽但有大量耗时任务时，其它任务调用Task.Factory.StartNew会有延迟

我想了一天，多任务还是不要共用线程池比较好，一个任务一个线程池，互不干扰，TaskHelper.LargeTask.Run就是按这个思路写的，不知道可有问题

附：

LimitedTaskScheduler代码：

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 LimitedTaskScheduler : 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 _timeOut = Timeout.Infinite;
        private Task _tempTask;

        public int ThreadCount
        {
            get
            {
                return _threadCount;
            }
        }
        #endregion

        #region 构造函数
        public LimitedTaskScheduler(int threadCount = 10)
        {
            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()
        {
            _timeOut = 100;

            foreach (Thread item in _threadList)
            {
                item.Abort();
            }
            _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++)
            {
                Thread thread = new Thread(new ThreadStart(() =>
                {
                    Task task;
                    while (_tasks.TryTake(out task, _timeOut))
                    {
                        TryExecuteTask(task);
                    }
                }));
                thread.IsBackground = true;
                thread.Start();
                _threadList.Add(thread);
            }
        }
        #endregion

        #region 全部取消
        /// <summary>
        /// 全部取消
        /// </summary>
        public void CancelAll()
        {
            while (_tasks.TryTake(out _tempTask)) { }
        }
        #endregion

    }
}

TaskHelper代码：

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 _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 _LargeTask;
        /// <summary>
        /// 大线程池任务(64个线程)
        /// </summary>
        public static LimitedTaskScheduler LargeTask
        {
            get
            {
                if (_LargeTask == null) _LargeTask = new LimitedTaskScheduler(128);
                return _LargeTask;
            }
        }
        #endregion

    }
}