成都都网站建设青岛网站建设公司

场景

有个Service类，自己在内部实现生产者/消费者模式。即多个指令输入该服务后对象后，Service内部有专门的消费线程执行传入的指令。每个指令的执行间隔为1秒。这里有两部分组成，

1. 工作线程的载体。new Thread与Task.Run。
2. 执行等待的方法。Thread.Sleep与Task.Delay。

测试环境

cpu: AMD 3700x 8核16线程
RAM：128G 3200MHz

示例代码

public class Service
{public Service(int id, Action f, int delayMillisecond = 1000){Id = id;F = f;DelayMillisecond = delayMillisecond;}private int DelayMillisecond;private BlockingCollection<Action> _collection = new BlockingCollection<Action>();public int Id { get; }public Action F { get; }public void AddAction(){_collection.Add(F);}public void Run1(){new Thread(Worker_Sleep).Start();}public void Run2(){new Thread(Worker_Delay).Start();}public void Run3(){Task.Run(Worker_Sleep);}public void Run4(){Task.Run(Worker_Delay);}private void Worker_Sleep(){{foreach (var action in _collection.GetConsumingEnumerable()){action?.Invoke();Thread.Sleep(DelayMillisecond);}}}private async void Worker_Delay(){{foreach (var action in _collection.GetConsumingEnumerable()){action?.Invoke();await Task.Delay(DelayMillisecond);}}}
}

使用BlockingCollection存储指令并通过GetConsumingEnumerable消费。

• run1。Thread+Thread.Sleep。
• run2。Thread+Task.Delay。
• run3。Task.Run+Thread.Sleep。
• run4。Task.Run+Task.Delay。

var serviceCount = 200; // 服务数量
var actionCount = 3; // 指令个数
var actionInterval = 1000; // 指令执行时间间隔ms
var services = new List<Service>();Action f = () =>
{Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss ffff")}\t{Thread.CurrentThread.ManagedThreadId}\tCount:{Count}");
};// 生成所有服务对象
for (int i = 0; i < serviceCount; i++)
{var s = new Service(i, f, actionInterval);services.Add(s);
}Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss ffff")}\tRun");
services.ForEach(s => s.Run2());while (true)
{// 输入任意内容，启动var msg = Console.ReadLine();Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss ffff")}\tStart!!!!!!!!!!");// 每个服务对象自行输入指令services.ForEach(s =>{for (int i = 0; i < actionCount; i++){s.AddAction();}});
}

测试参数组为
serviceCount，50,100,200,500,1000。（其他使用默认）

类型	对象个数	指令个数	间隔	完成耗时
run1	50	3	1	2.3s
run1	100	3	1	2.1s
run1	200	3	1	2.2s
run1	500	3	1	2.4s
run1	1000	3	1	2.9s
run2	50	3	1	2.3s
run2	100	3	1	2.5s
run2	200	3	1	3.1s
run2	500	3	1	5.2s
run2	1000	3	1	10.5s
run3	50	3	1	27s
run3	100	3	1	78s
run3	200	3	1	-
run3	500	3	1	-
run3	1000	3	1	-
run4	50	3	1	2.2s
run4	100	3	1	2.1s
run4	200	3	1	2.2s
run4	500	3	1	2.4s
run4	1000	3	1	2.7s

3个指令，1秒间隔，理想状态下，完成耗时应是2秒。且随着对象个数增多，仍然能保持在一个合理范围。
由以上数据可知，run1和run4是在时间消耗上比较符合期望。

• run1。Thread+Thread.Sleep。
• run4。Task.Run+Task.Delay。

我们更改参数，比较两者的cpu占用情况。测试参数如下：
服务数量：serviceCount=2000
指令个数：actionCount=50
指令执行时间间隔/ms：actionInterval = 1000
cpu占用情况如图。

服务数量：serviceCount=200
指令个数：actionCount=50
指令执行时间间隔/ms：actionInterval = 1000
cpu占用情况如图。

基于这两张图，可以得到初步结论：

1. Task.Run+Task.Delay在初始化阶段需要占用较大的cpu资源。后续较为平稳，对数量的增加并不敏感（200到2000）
2. Thread+Thread.Sleep在初始化期间与正常运行两个周期，前后一致性较强。但是对数量的增加敏感（200到2000）