以后在准确的持续时间内安排许多任务的正确方法是什么？

如何解决以后在准确的持续时间内安排许多任务的正确方法是什么？

我的最终目标是安排许多类似的任务以一致的周期重复运行，并将它们分布在它们的周期内，以避免 CPU 需求激增。

对于第一步，我尝试找到正确的方法来安排任务以在以后运行一个确切的持续时间。我在这一步的尝试都没有奏效。

public static void Main(string[] args)
{
    Console.WriteLine("Entry");

    const int n = 1000;
    int[] times = new int[n];
    Task[] tasks = new Task[n];

    DateTime wctStart = DateTime.Now;
    for (int i = 0; i < n; i++)
    {
        int ibv = i;
        DateTime now = DateTime.Now;

        // For n = 1,000 we expect s >= 1,000,000; wct >= 1,000

        // n=1,000 -> s=30k-80k; wct=200
        //tasks[i] = Task.Delay(1000)
        //    .ContinueWith(_ =>
        //    {
        //        times[ibv] = (DateTime.Now - now).Milliseconds;
        //    });

        // n=1,000 -> s=190k-300k; wct=200-400
        // This also takes 50 seconds and eats 2-3MB mem
        //tasks[i] = Task.Run(delegate
        //{
        //    Thread.Sleep(1000);
        //    times[ibv] = (DateTime.Now - now).Milliseconds;
        //});


        // n=1,000 -> s=30k-400k; wct=300-500
        //tasks[i] = Task.Run(async () =>
        //{
        //    await Task.Delay(1000);
        //    times[ibv] = (DateTime.Now - now).Milliseconds;
        //});
    }

    foreach (Task task in tasks)
    {
        task.Wait();
    }

    int s = 0;
    foreach (int v in times)
    {
        s += v;
    }

    int wct = (DateTime.Now - wctStart).Milliseconds;
    Console.WriteLine($"s={s:N0},wct={wct:N0}");

    Console.ReadKey();
}

要运行此代码，请先取消三个选项之一的注释。

我正在安排 1,000 个任务在 1,000 毫秒后运行。每个人都会获得一个索引并存储它在创建后运行的毫秒数。我期望的值以及表示正确解决方案的值是 1,000 毫秒或多几毫秒的统一测量值，因此 s 的值不小于 1,000，但可能高达几千多，以及 wct 挂钟时间至少为 1,​​000 或以类似比例更大。

相反，我观察到的是，所有这三种方法都给出了不同范围内 s 的广泛可变值，都远小于 1,000，而 wct 的微小可变值都远小于 1,000。

为什么这些方法显然不起作用，如何解决？

解决方法

来自 TimeSpan.Milliseconds 属性的文档：

public int Milliseconds { get; }

获取当前 TimeSpan 结构表示的时间间隔的毫秒分量。

所以 Milliseconds 返回一个 0 - 999 之间的值。要以毫秒为单位获取 TimeSpan 的总持续时间，您需要查询 TimeSpan.TotalMilliseconds 属性：

public double TotalMilliseconds { get; }

获取以整数和小数毫秒表示的当前 TimeSpan 结构的值。

我的建议是使用 Stopwatch 类来测量间隔。它比减去由 DateTime 属性获得的 DateTime.Now 更准确、更轻量。

---

更新：以下是用于创建函数定期执行的基本脚手架，具有可配置的间隔和并发策略：

var concurrentScheduler = new ConcurrentExclusiveSchedulerPair(
    TaskScheduler.Default,maxConcurrencyLevel: 2).ConcurrentScheduler;

var cts = new CancellationTokenSource();

Task PeriodicExecutionAsync(TimeSpan interval,Action action)
{
    return Task.Factory.StartNew(async () =>
    {
        while (true)
        {
            var delayTask = Task.Delay(interval,cts.Token);
            action();
            await delayTask; // Continue on captured context
            cts.Token.ThrowIfCancellationRequested();
        }
    },cts.Token,TaskCreationOptions.DenyChildAttach,concurrentScheduler).Unwrap();
}

Task periodicExecution1 = PeriodicExecutionAsync(TimeSpan.FromSeconds(1.0),() =>
{
    Thread.Sleep(200); // Simulate CPU-bound work
});

Task periodicExecution2 = PeriodicExecutionAsync(TimeSpan.FromSeconds(2.0),() =>
{
    Thread.Sleep(500); // Simulate CPU-bound work
});

为了正常终止，您可以在关闭程序之前调用 cts.Cancel()，然后等待所有任务完成。您可以安全地捕获并忽略任何 OperationCanceledException，它们是良性的。