场景

有个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）