循环运行任务

Question

我有一个函数可能需要 5-60 秒才能运行，我需要每 10 秒运行一次，但它应该仅在先前启动的函数完成运行时才启动，我现在的代码是

Action myAction = new Action(() =>
    {
        Debug.WriteLine("just testing");
        Thread.Sleep(15000);
    });
Task myTask = Task.Factory.StartNew(myAction, _cts.Token);
Timer myTimer = new Timer(state =>
    {
        if (myTask.IsCompleted)
        {
            myTask = Task.Factory.StartNew(myAction, _cts.Token);
        }
    }, null, 10000, 10000);

一切正常，但我想知道如果我的问题有更好的解决方案吗？或者是否有可能不创建新任务（Task.Factory.StartNew）而仅使用 myTimer 使用的任务？

Answer 1

您可以使用ContinueWith()：

Task.Factory.StartNew(myAction, _cts.Token).ContinueWith(_ => myAction);

查找它的重载，它有很多选项来控制在哪些情况下运行延续。

Answer 2

有一个很棒的开源任务调度程序，称为 Quartz.net。您可以在 http://quartznet.sourceforge.net/ 找到它，

它支持您提到的特定场景。这是一个非常强大的解决方案，具有良好的可扩展性。

Answer 3

如果您喜欢冒险，另一种可能性是使用 Rx：

Observable.Timer(TimeSpan.FromSeconds(10)).TakeUntilCanceled(cancel).Subscribe(_ => myAction);

使用 TakeUntilCanceled 扩展：

public static class CancellationTokenXs
{
    public static IObservable<T>
    TakeUntilCanceled<T>(this IObservable<T> source, CancellationToken cancellationToken)
    {
        var subject = new Subject<Unit>();
        cancellationToken.Register(() => subject.OnNext(new Unit()), true);
        return source.TakeUntil(subject);
    }
}

Answer 4

更好的想法是，不要尝试每 10 秒调用一次，而是依赖任务完成时的回调，如以下代码中的示例：

        DateTime sinceExec = DateTime.Now;
        BackgroundWorker bgWorker = new BackgroundWorker();
        bgWorker.DoWork += (bgSender, bgArgs) =>
        {
            sinceExec = DateTime.Now;
            Debug.WriteLine("Test!");
            Thread.Sleep(5000);
        };
        bgWorker.RunWorkerCompleted += (bgSender, bgArgs) =>
        {
            // it didn't take 10000 milliseconds
            if ((DateTime.Now - sinceExec).Milliseconds < 10000) 
            {
                //Calculate time to wait
                TimeSpan timeToWait = (DateTime.Now - sinceExec);

                // wait that amount of time
                Thread.Sleep(timeToWait);
            }
            //Re-execute the worker
            bgWorker.RunWorkerAsync();
        };

        bgWorker.RunWorkerAsync();

BackgroundWorker 类的功能使得事件处理程序 DoWork 在调用 RunWorkerAsync() 时执行，在 DoWork 完成时调用 RunWorkerCompleted。

Answer 5

您可以使用锁定语句。 lock 语句创建一个关键部分，对于给定对象一次只能运行其中一个。

使用主线程和任务线程都可以访问的对象作为互斥锁。围绕任务函数的代码和使用 lock 语句启动任务的行将实现您的目标。任务函数将获取锁，并且在完成之前不会释放它，而创建函数将等待获取锁，然后再创建另一个任务。

Action myAction = new Action(() =>
{
    lock(this)
    {
        Debug.WriteLine("just testing");
        Thread.Sleep(15000);
    }
});

在启动操作的代码中，

lock(myAction)
{
    Task.Factory.StartNew(myAction, _cts.Token)
}