同时触发重复任务

Question

我试图让 2 个任务在特定时间点同时触发，然后重新执行。例如，下面是等待 1 分钟的任务和等待 5 分钟的第二个任务。 1 分钟任务应在 5 分钟内触发 5 次，5 分钟任务应在 1 次内触发，1 分钟任务应在 10 分钟内触发 10 次，5 分钟任务应在 2 次内触发，如此循环。但是，我需要 1 分钟的任务与 5 分钟的任务同时触发。

我可以使用 System.Timers 来做到这一点，但这与我最终需要的多线程处理效果不佳。 System.Thread 没有任何与 System.Timers AutoReset 等效的东西，除非我遗漏了什么。

我下面的内容是两个延迟计时器同时启动，但 t1 只触发 1 次而不是 5 次。本质上它需要继续运行，直到程序停止 X 次为止。

            int i = 0;
            while (i < 1)
            {

                Task t1 = Task.Run(async delegate
                {
                    await Task.Delay(TimeSpan.FromMinutes(1));
                    TaskWorkers.OneMinuteTasks();
                });
                //t1.Wait();

                Task t2 = Task.Run(async delegate
                {
                    await Task.Delay(TimeSpan.FromMinutes(5));
                    TaskWorkers.FiveMinuteTasks();
                });
                t2.Wait();
            } 

更新 我首先阅读了下面的 Johns 评论，内容是为任务添加一个内部循环。下面按我的意愿工作。简单的修复。我知道我确实说过只要程序运行我就希望它运行，但我能够计算出我实际需要的最大循环数。 x

                Task t1 = Task.Run(async delegate
                    {
                        for(int x = 0; x < 10; x++)
                        {
                            await Task.Delay(TimeSpan.FromMinutes(1));
                            TaskWorkers.OneMinuteTasks();
                        }
                    });

                Task t2 = Task.Run(async delegate
                {
                    for (int x = 0; x < 10; x++)
                    {
                        await Task.Delay(TimeSpan.FromMinutes(5));
                        TaskWorkers.FiveMinuteTasks();
                    }
                });

据我所知，没有 CPU 或内存的总使用量。

Answer 1

您可以有一个循环以协调的方式定期触发任务：

async Task LoopAsync(CancellationToken token)
{
    while (true)
    {
        Task a = DoAsync_A(); // Every 5 minutes
        for (int i = 0; i < 5; i++)
        {
            var delayTask = Task.Delay(TimeSpan.FromMinutes(1), token);
            Task b = DoAsync_B(); // Every 1 minute
            await Task.WhenAll(b, delayTask);
            if (a.IsCompleted) await a;
        }
        await a;
    }
}

此实现在开始一个新的 1 分钟循环之前等待 B 任务和 Task.Delay 任务完成，因此如果 B 任务运行时间过长，则计划将滑倒。这可能是一种可取的行为，除非您可以接受重叠任务的可能性。

如果 A 或 B 任务发生异常，循环将在一分钟检查点报告失败。这并不理想，但让循环完美响应错误会使代码变得相当复杂。

---

更新：这是一个高级版本，在出现异常时响应更快。它使用链接的CancellationTokenSource，当两个任务中的任何一个失败时自动取消，然后立即取消延迟任务。

async Task LoopAsync(CancellationToken token)
{
    using (var linked = CancellationTokenSource.CreateLinkedTokenSource(token))
    {
        while (true)
        {
            Task a = DoAsync_A(); // Every 5 minutes
            await WithCompletionAsync(a, async () =>
            {
                OnErrorCancel(a, linked);
                for (int i = 0; i < 5; i++)
                {
                    var delayTask = Task.Delay(TimeSpan.FromMinutes(1),
                        linked.Token);
                    await WithCompletionAsync(delayTask, async () =>
                    {
                        Task b = DoAsync_B(); // Every 1 minute
                        OnErrorCancel(b, linked);
                        await b;
                        if (a.IsCompleted) await a;
                    });
                }
            });
        }
    }
}

async void OnErrorCancel(Task task, CancellationTokenSource cts)
{
    try
    {
        await task.ConfigureAwait(false);
    }
    catch
    {
        cts.Cancel();
        //try { cts.Cancel(); } catch { } // Safer alternative
    }
}

async Task WithCompletionAsync(Task task, Func<Task> body)
{
    try
    {
        await body().ConfigureAwait(false);
    }
    catch (OperationCanceledException)
    {
        await task.ConfigureAwait(false);
        throw; // The task isn't faulted. Propagate the exception of the body.
    }
    catch
    {
        try
        {
            await task.ConfigureAwait(false);
        }
        catch { } // Suppress the task's exception
        throw; // Propagate the exception of the body
    }
    await task.ConfigureAwait(false);
}

这个版本的逻辑比最初的简单版本要复杂得多（这使得它更容易出错）。 CancellationTokenSource 的引入产生了处理它的需要，这反过来又强制确保所有任务都将在异步方法的每个退出点完成。这就是使用WithCompletionAsync 方法将每个任务之后的所有代码封装在LoopAsync 方法内的原因。

Answer 2

我认为计时器或类似 Vasily 的建议将是可行的方法，因为这些解决方案旨在处理重复性任务，而不仅仅是使用线程。但是，您可以使用线程来执行此操作，例如：

    void TriggerTimers()
    {
        new Thread(() =>
        {
            while (true)
            {
                new Thread(()=> TaskA()).Start();
                Thread.Sleep(60 * 1000); //start taskA every minute
            }

        }).Start();

        new Thread(() =>
        {
            while (true)
            {
                new Thread(() => TaskB()).Start();
                Thread.Sleep(5 * 60 * 1000); //start taskB every five minutes
            }

        }).Start();
    }

    void TaskA() { }

    void TaskB() { }

请注意，如果在很长一段时间内使用此解决方案，我会产生少量偏差，尽管除非您处理非常精细的边距或非常过载的计算机，否则这应该不会很重要。此外，这个解决方案对 John 提到的描述没有偶然性 - 它相当轻量级，但也很容易理解