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

Question

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

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

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,000，但可能高达几千多，并且 wct 挂钟时间至少为 1,000，或以类似的比例更大。

我观察到的是，所有这三种方法都在不同的运行ges 中给出了广泛可变的 s 值，这些值都远小于 1,000,000，而 wct 的可变值很小都远少于 1,000。

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

Answer 1

来自 TimeSpan.Milliseconds 属性的文档：

public int Milliseconds { get; }

Gets the milliseconds component of the time interval represented by the current TimeSpan structure.

所以 Milliseconds return 是一个介于 0 - 999 之间的值。要获得 TimeSpan 的总持续时间（以毫秒为单位），您需要查询 TimeSpan.TotalMilliseconds 属性:

public double TotalMilliseconds { get; }

Gets the value of the current TimeSpan structure expressed in whole and fractional milliseconds.

我的建议是使用Stopwatch class 来测量间隔。它比 DateTime.Now 属性.

减去 DateTimes 更准确，更轻量级

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

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()，然后等待所有任务完成。您可以安全地捕获并忽略任何 OperationCanceledExceptions，它们是良性的。

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

What's the correct way to schedule many tasks for an accurate duration later?

c#

multithreading

timing

threadpool