Task.Factory.StartNew 测试
到底该用多少线程？线程数、CPU核心数、本地计算时间、等待时间的关系 线程数 = CPU核心数 * ( 本地计算时间 + 等待时间 ) / 本地计算时间
下面是Task.Factory.StartNew和自己写的TaskHelper.LargeTask.Run对比测试
一、Task.Factory.StartNew 使用 TaskCreationOptions.LongRunning 参数
代码：
private int n = ; //问题规模
private int t = ; //等待时间
private int pageSize = ; //打印分页 private void TestTaskStartNew()
{
Task.Factory.StartNew(() =>
{
Stopwatch stopwatch = Stopwatch.StartNew(); List<Task> taskList = new List<Task>();
for (int i = ; i <= n; i++)
{
Task task = Task.Factory.StartNew((obj) =>
{
Thread.Sleep(t); //等待时间 int index = (int)obj;
if (index % pageSize == )
{
this.TryInvoke2(() =>
{
textBox1.AppendText(index.ToString() + " ");
});
}
}, i, TaskCreationOptions.LongRunning);
taskList.Add(task);
}
Task.WaitAll(taskList.ToArray()); this.TryInvoke2(() =>
{
textBox1.AppendText(string.Format("\r\n【Task.Factory.StartNew 问题规模:{0} 等待时间:{1} 耗时：{2}秒】\r\n", n, t, stopwatch.Elapsed.TotalSeconds));
});
});
} private void TestTaskHelper()
{
Task.Factory.StartNew(() =>
{
Stopwatch stopwatch = Stopwatch.StartNew(); List<Task> taskList = new List<Task>();
for (int i = ; i <= n; i++)
{
Task task = TaskHelper.LargeTask.Run((obj) =>
{
Thread.Sleep(t); //等待时间 int index = (int)obj;
if (index % pageSize == )
{
this.TryInvoke2(() =>
{
textBox1.AppendText(index.ToString() + " ");
});
}
}, i);
taskList.Add(task);
}
Task.WaitAll(taskList.ToArray()); this.TryInvoke2(() =>
{
textBox1.AppendText(string.Format("\r\n【TaskHelper.LargeTask.Run {3}线程 问题规模:{0} 等待时间:{1} 耗时：{2}秒】\r\n", 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 = ; //问题规模
private int t = ; //等待时间
private int pageSize = ; //打印分页 private void TestTaskStartNew()
{
Task.Factory.StartNew(() =>
{
Stopwatch stopwatch = Stopwatch.StartNew(); List<Task> taskList = new List<Task>();
for (int i = ; i <= n; i++)
{
Task task = Task.Factory.StartNew((obj) =>
{
Thread.Sleep(t); //等待时间 int index = (int)obj;
if (index % pageSize == )
{
this.TryInvoke2(() =>
{
textBox1.AppendText(index.ToString() + " ");
});
}
}, i);
taskList.Add(task);
}
Task.WaitAll(taskList.ToArray()); this.TryInvoke2(() =>
{
textBox1.AppendText(string.Format("\r\n【Task.Factory.StartNew 问题规模:{0} 等待时间:{1} 耗时：{2}秒】\r\n", n, t, stopwatch.Elapsed.TotalSeconds));
});
});
} private void TestTaskHelper()
{
Task.Factory.StartNew(() =>
{
Stopwatch stopwatch = Stopwatch.StartNew(); List<Task> taskList = new List<Task>();
for (int i = ; i <= n; i++)
{
Task task = TaskHelper.LargeTask.Run((obj) =>
{
Thread.Sleep(t); //等待时间 int index = (int)obj;
if (index % pageSize == )
{
this.TryInvoke2(() =>
{
textBox1.AppendText(index.ToString() + " ");
});
}
}, i);
taskList.Add(task);
}
Task.WaitAll(taskList.ToArray()); this.TryInvoke2(() =>
{
textBox1.AppendText(string.Format("\r\n【TaskHelper.LargeTask.Run {3}线程 问题规模:{0} 等待时间:{1} 耗时：{2}秒】\r\n", 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 = ;
private int _timeOut = Timeout.Infinite;
private Task _tempTask; public int ThreadCount
{
get
{
return _threadCount;
}
}
#endregion #region 构造函数
public LimitedTaskScheduler(int threadCount = )
{
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 = ; 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, -, -);
}
}
#endregion #region 创建线程池
/// <summary>
/// 创建线程池
/// </summary>
private void CreateThreads(int? threadCount = null)
{
if (threadCount != null) _threadCount = threadCount.Value;
_timeOut = Timeout.Infinite; for (int i = ; 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();
return _UITask;
}
}
#endregion #region 计算任务
private static LimitedTaskScheduler _CalcTask;
/// <summary>
/// 计算任务(8个线程)
/// </summary>
public static LimitedTaskScheduler CalcTask
{
get
{
if (_CalcTask == null) _CalcTask = new LimitedTaskScheduler();
return _CalcTask;
}
}
#endregion #region 网络请求
private static LimitedTaskScheduler _RequestTask;
/// <summary>
/// 网络请求(32个线程)
/// </summary>
public static LimitedTaskScheduler RequestTask
{
get
{
if (_RequestTask == null) _RequestTask = new LimitedTaskScheduler();
return _RequestTask;
}
}
#endregion #region 数据库任务
private static LimitedTaskScheduler _DBTask;
/// <summary>
/// 数据库任务(32个线程)
/// </summary>
public static LimitedTaskScheduler DBTask
{
get
{
if (_DBTask == null) _DBTask = new LimitedTaskScheduler();
return _DBTask;
}
}
#endregion #region IO任务
private static LimitedTaskScheduler _IOTask;
/// <summary>
/// IO任务(8个线程)
/// </summary>
public static LimitedTaskScheduler IOTask
{
get
{
if (_IOTask == null) _IOTask = new LimitedTaskScheduler();
return _IOTask;
}
}
#endregion #region 大线程池任务
private static LimitedTaskScheduler _LargeTask;
/// <summary>
/// 大线程池任务(64个线程)
/// </summary>
public static LimitedTaskScheduler LargeTask
{
get
{
if (_LargeTask == null) _LargeTask = new LimitedTaskScheduler();
return _LargeTask;
}
}
#endregion }
}
Task.Factory.StartNew 测试的更多相关文章
- Task.Factory.StartNew的用法
代码: private void button5_Click(object sender, EventArgs e) { ; Task.Factory.StartNew(() => { Mess ...
- Task.Run Vs Task.Factory.StartNew
在.Net 4中,Task.Factory.StartNew是启动一个新Task的首选方法.它有很多重载方法,使它在具体使用当中可以非常灵活,通过设置可选参数,可以传递任意状态,取消任务继续执行,甚至 ...
- Task.Run Vs Task.Factory.StartNew z
在.Net 4中,Task.Factory.StartNew是启动一个新Task的首选方法.它有很多重载方法,使它在具体使用当中可以非常灵活,通过设置可选参数,可以传递任意状态,取消任务继续执行,甚至 ...
- Task.Run与Task.Factory.StartNew的区别
Task是可能有延迟的工作单元,目的是生成一个结果值,或产生想要的效果.任务和线程的区别是:任务代表需要执行的作业,而线程代表做这个作业的工作者. 在.Net 4中,Task.Factory.Star ...
- C# Task.Run 和 Task.Factory.StartNew 区别
Task.Run 是在 dotnet framework 4.5 之后才可以使用,但是 Task.Factory.StartNew 可以使用比 Task.Run 更多的参数,可以做到更多的定制.可以认 ...
- Task.Run Vs Task.Factory.StartNew 【收藏】
在.Net 4中,Task.Factory.StartNew是启动一个新Task的首选方法.它有很多重载方法,使它在具体使用当中可以非常灵活,通过设置可选参数,可以传递任意状态,取消任务继续执行,甚至 ...
- c#4.0 Task.Factory.StartNew 用法
var t1 = Task.Factory.StartNew<string>(() => { return “1111111”; }); //t1.Wait(); t1.Contin ...
- task.factory.startnew()
1.委托: public delegate int Math(int param1,int param2);定义委托类型 Public int Add(int param1,int param2)// ...
- 单线程任务 Task.Factory.StartNew 封装
代码: using log4net; using SunCreate.CombatPlatform.Security; using System; using System.Collections.G ...
随机推荐
- java的回调和C#的委托
曾经有人对我说java的回调很巧妙. 今天我自己看了一下,回调的关键就是一个接口的事情. 也许是因为用了一定的手法,一开始不好懂吧,所以看懂了会感觉巧妙. 但是我心里的想法却是,真啰嗦! 回调的实例 ...
- 2019-9-10：渗透测试，基础学习，nmap扫描命令，php基本语法学习，笔记
nmap参数-sT,使用tcp全连接的方式 ,扫描过程需要三次握手,建立链接,则说明端口开放,扫描速度慢-sS,使用syn的数据包去检测,接收到ACK说明端口开放-sN,null扫描,发出去的数据包不 ...
- python 正确字符串处理（自己踩过的坑）
不管是谁,只要处理过由用户提交的调查数据,就能明白这种乱七八糟的数据是怎么一回事.为了得到一组能用于分析工作的格式统一的字符串,需要做很多事情:去除空白符.删除各种标点符号.正确的大写格式等.做法之一 ...
- jquery浅复制和深复制区别
jquery浅复制和深复制区别
- Linux查看系统基本信息、版本信息等
Linux下如何查看版本信息, 包括位数.版本信息以及CPU内核信息.CPU具体型号 1.uname -a (Linux查看版本当前操作系统内核信息) 2.cat /proc/version (L ...
- Selenium+Java（十一）Selenium窗口切换
前言: Selenium在当前页面调整到新页面时打开了新的窗口,此时就需要跳转到新的窗口去,需要把窗口进行切换. 获取窗口句柄方法: 获取所有: //获取所有窗口句柄,返回的是set类型 driver ...
- 【并发编程】关于Thread类的详细介绍
多线程编程基础--Thread类 Thread类是Java中实现多线程编程的基础类.本篇博客就来介绍下Thread类的常用API和常见用法. Thread类常用的方法如下: Thread.active ...
- linux搭建Git
安装依赖库和编译工具为了后续安装能正常进行,我们先来安装一些相关依赖库和编译工具yum install curl-devel expat-devel gettext-devel openssl-dev ...
- golang数据结构之循环链表
循环链表还是挺有难度的: 向链表中插入第一条数据的时候如何进行初始化. 删除循环链表中的数据时要考虑多种情况. 详情在代码中一一说明. 目录结构如下: circleLink.go package li ...
- 漫谈LiteOS之开发板-GPIO（基于GD32450i-EVAL）
[摘要] 本文主要从GPIO的定义.工作模式.特色.工作场合.以及GD32450i-EVAL开发板的引脚.对应的寄存器以及GPIO的流水灯示例对GPIO加以介绍,希望对你有所帮助. 1定义 GPIO( ...