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 ...
随机推荐
- PHP开发各种规范，面试秘籍！
基本约定 源文件 代码使用<?php开头,忽略闭合标签?> 文件格式必须是无BOM UTF-8格式 一个文件只声明一种类型,如class和interface不能混写在一个源文件中 缩进 使 ...
- 原生JS通过类名(className)获取dom元素
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title> ...
- Python的特有的参数传递（*和**）
目录 值传递 引用传递 python的传递方式具有两种值传递和引用传递.除此之外,python中还允许包裹方式的参数传递,这未不确定参数个数和参数类型的函数调用提供了基础: 值传递 int.float ...
- session与cookie的介绍和两者的区别之其相互的关系
转:https://blog.csdn.net/weixin_37196194/article/details/55806366 本文分别对Cookie与Session做一个介绍和总结,并分别对两个知 ...
- JS获取当前完整的url地址以及参数的方法
javascript 获取当前 URL 参数的两种方法: //返回的是字符串形式的参数,例如:class_id=3&id=2& function getUrlArgStr(){ var ...
- oracle创建jobs定时任务报错：ora-01008:not all variables bound
原脚本(直接从jobs拖出生成的DDL): begin sys.dbms_job.submit(job => :job, what => 'xx ...
- 基于Win服务的标签打印(模板套打)
最近做了几个项目,都有在产品贴标的需求 基本就是有个证卡类打印机,然后把产品的信息打印在标签上. 然后通过机器人把标签贴到产品上面 标签信息包括文本,二维码,条形码之类的,要根据对应的数据生成二维码, ...
- MyBatis的配置与使用(增,删,改,查)
---恢复内容开始--- Mybatis入门介绍 一.MyBatis介绍 什么是MyBtis? MyBatis 是一个简化和实现了 Java 数据持久化层(persistence layer)的开源框 ...
- 华为云ROMA，联接企业应用的现在与未来
2019.9.19日,在华为全联接大会的华为云Summit中,华为云CTO宇昕总提出:"企业的应用与数据集成,始终是数字化转型和智能化升级的关键,华为云企业应用与数据集成平台ROMA,打破时 ...
- 时至今日，我们应该承认.Net目前的状况实在堪忧
一: .Net之前 .Net 经历了多年的锤炼,语言特性本身非常优雅和完善,也是非常甜品的一种语言 二: .Net现状 但是与此同时,.Net的生态日益糟糕,困扰着广大.Neter 三: .N ...