异步等待 Task<T> 超时完成

StackOverflow https://stackoverflow.com/questions/4238345

  •  26-09-2019
  •  | 
  •  

题

我想等待 任务<T> 完成一些特殊规则：如果 X 毫秒后仍未完成，我想向用户显示一条消息。如果它在 Y 毫秒后还没有完成，我想自动 取消请求.

我可以用 任务.ContinueWith 异步等待任务完成（即安排任务完成时执行的操作），但这不允许指定超时。我可以用 任务等待 同步等待任务完成并超时，但这会阻塞我的线程。如何异步等待任务完成并超时？

有帮助吗？

解决方案

这样如何：

int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
    // task completed within timeout
} else { 
    // timeout logic
}

和这里的一个伟大的博客文章“制作一个任务.TimeoutAfter法”（从MS并行库团队）对这种事情的更多信息。

<强>加成：在上我的回答注释的请求，这里是一个扩展的解决方案，其包括消除处理。注意，通过取消该任务和定时装置，有多种方式可以消除在代码中的经历，你应该确保试验，并相信你妥善处理所有的人。不要让侥幸心理的各种组合，并希望你的电脑做正确的事，在运行时。

int timeout = 1000;
var task = SomeOperationAsync(cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) == task)
{
    // Task completed within timeout.
    // Consider that the task may have faulted or been canceled.
    // We re-await the task so that any exceptions/cancellation is rethrown.
    await task;

}
else
{
    // timeout/cancellation logic
}

其他提示

下面是当在评论建议由Andrew阿诺特原始任务完成对他的答案结合了超时解除的扩展方法版本。 

public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout) {

    using (var timeoutCancellationTokenSource = new CancellationTokenSource()) {

        var completedTask = await Task.WhenAny(task, Task.Delay(timeout, timeoutCancellationTokenSource.Token));
        if (completedTask == task) {
            timeoutCancellationTokenSource.Cancel();
            return await task;  // Very important in order to propagate exceptions
        } else {
            throw new TimeoutException("The operation has timed out.");
        }
    }
}

您可以使用Task.WaitAny等待第一多个任务。

您可以创建两个附加任务（指定的超时后完成），然后使用WaitAny等待以先到者为准完成了。如果完成了任务第一个是你的“工作”的任务，那么你就大功告成了。如果先完成了任务是超时的任务，则可以将超时（例如请求取消）反应

关于这样的事情是什么？

    const int x = 3000;
    const int y = 1000;

    static void Main(string[] args)
    {
        // Your scheduler
        TaskScheduler scheduler = TaskScheduler.Default;

        Task nonblockingTask = new Task(() =>
            {
                CancellationTokenSource source = new CancellationTokenSource();

                Task t1 = new Task(() =>
                    {
                        while (true)
                        {
                            // Do something
                            if (source.IsCancellationRequested)
                                break;
                        }
                    }, source.Token);

                t1.Start(scheduler);

                // Wait for task 1
                bool firstTimeout = t1.Wait(x);

                if (!firstTimeout)
                {
                    // If it hasn't finished at first timeout display message
                    Console.WriteLine("Message to user: the operation hasn't completed yet.");

                    bool secondTimeout = t1.Wait(y);

                    if (!secondTimeout)
                    {
                        source.Cancel();
                        Console.WriteLine("Operation stopped!");
                    }
                }
            });

        nonblockingTask.Start();
        Console.WriteLine("Do whatever you want...");
        Console.ReadLine();
    }

可以使用Task.Wait选项而不阻断使用另一个任务主线程。

这是一个基于投票最高答案的完整示例，即：

int timeout = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
    // task completed within timeout
} else { 
    // timeout logic
}

这个答案中实现的主要优点是添加了泛型，因此函数（或任务）可以返回一个值。这意味着任何现有函数都可以包装在超时函数中，例如：

前： 

int x = MyFunc();

后：

// Throws a TimeoutException if MyFunc takes more than 1 second
int x = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));

此代码需要 .NET 4.5。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace TaskTimeout
{
    public static class Program
    {
        /// <summary>
        ///     Demo of how to wrap any function in a timeout.
        /// </summary>
        private static void Main(string[] args)
        {

            // Version without timeout.
            int a = MyFunc();
            Console.Write("Result: {0}\n", a);
            // Version with timeout.
            int b = TimeoutAfter(() => { return MyFunc(); },TimeSpan.FromSeconds(1));
            Console.Write("Result: {0}\n", b);
            // Version with timeout (short version that uses method groups). 
            int c = TimeoutAfter(MyFunc, TimeSpan.FromSeconds(1));
            Console.Write("Result: {0}\n", c);

            // Version that lets you see what happens when a timeout occurs.
            try
            {               
                int d = TimeoutAfter(
                    () =>
                    {
                        Thread.Sleep(TimeSpan.FromSeconds(123));
                        return 42;
                    },
                    TimeSpan.FromSeconds(1));
                Console.Write("Result: {0}\n", d);
            }
            catch (TimeoutException e)
            {
                Console.Write("Exception: {0}\n", e.Message);
            }

            // Version that works on tasks.
            var task = Task.Run(() =>
            {
                Thread.Sleep(TimeSpan.FromSeconds(1));
                return 42;
            });

            // To use async/await, add "await" and remove "GetAwaiter().GetResult()".
            var result = task.TimeoutAfterAsync(TimeSpan.FromSeconds(2)).
                           GetAwaiter().GetResult();

            Console.Write("Result: {0}\n", result);

            Console.Write("[any key to exit]");
            Console.ReadKey();
        }

        public static int MyFunc()
        {
            return 42;
        }

        public static TResult TimeoutAfter<TResult>(
            this Func<TResult> func, TimeSpan timeout)
        {
            var task = Task.Run(func);
            return TimeoutAfterAsync(task, timeout).GetAwaiter().GetResult();
        }

        private static async Task<TResult> TimeoutAfterAsync<TResult>(
            this Task<TResult> task, TimeSpan timeout)
        {
            var result = await Task.WhenAny(task, Task.Delay(timeout));
            if (result == task)
            {
                // Task completed within timeout.
                return task.GetAwaiter().GetResult();
            }
            else
            {
                // Task timed out.
                throw new TimeoutException();
            }
        }
    }
}

注意事项

给出这个答案后，一般来说 不是 在正常操作期间在代码中抛出异常是一个好习惯，除非您绝对必须：

  • 每次抛出异常都是一次极其重量级的操作，
  • 如果异常处于紧密循环中，则异常可能会使代码速度降低 100 倍或更多。

仅当您绝对无法更改正在调用的函数时才使用此代码，因此它会在特定时间后超时 TimeSpan.

这个答案实际上只适用于处理第三方库时，您根本无法重构以包含超时参数。

如何编写健壮的代码

如果你想编写健壮的代码，一般规则是这样的：

每个可能无限期阻塞的操作都必须有超时。

如果你 不要 遵守此规则，您的代码最终将遇到因某种原因失败的操作，然后它将无限期地阻塞，并且您的应用程序将永久挂起。

如果一段时间后出现合理的超时，那么您的应用程序将挂起一段极端的时间（例如30 秒），那么它要么显示错误并继续其快乐的方式，要么重试。

使用一个定时器来处理消息和自动取消。任务完成后，调用Dispose的计时器，让他们将永远不会触发。下面是一个例子;变化taskDelay〜500，1500，或2500以查看不同的情况：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        private static Task CreateTaskWithTimeout(
            int xDelay, int yDelay, int taskDelay)
        {
            var cts = new CancellationTokenSource();
            var token = cts.Token;
            var task = Task.Factory.StartNew(() =>
            {
                // Do some work, but fail if cancellation was requested
                token.WaitHandle.WaitOne(taskDelay);
                token.ThrowIfCancellationRequested();
                Console.WriteLine("Task complete");
            });
            var messageTimer = new Timer(state =>
            {
                // Display message at first timeout
                Console.WriteLine("X milliseconds elapsed");
            }, null, xDelay, -1);
            var cancelTimer = new Timer(state =>
            {
                // Display message and cancel task at second timeout
                Console.WriteLine("Y milliseconds elapsed");
                cts.Cancel();
            }
                , null, yDelay, -1);
            task.ContinueWith(t =>
            {
                // Dispose the timers when the task completes
                // This will prevent the message from being displayed
                // if the task completes before the timeout
                messageTimer.Dispose();
                cancelTimer.Dispose();
            });
            return task;
        }

        static void Main(string[] args)
        {
            var task = CreateTaskWithTimeout(1000, 2000, 2500);
            // The task has been started and will display a message after
            // one timeout and then cancel itself after the second
            // You can add continuations to the task
            // or wait for the result as needed
            try
            {
                task.Wait();
                Console.WriteLine("Done waiting for task");
            }
            catch (AggregateException ex)
            {
                Console.WriteLine("Error waiting for task:");
                foreach (var e in ex.InnerExceptions)
                {
                    Console.WriteLine(e);
                }
            }
        }
    }
}

此外，异步CTP 提供TaskEx.Delay方法，该方法将包装在任务定时器为您服务。这可以给你更多的控制权，为延续当定时器触发不喜欢的东西设置的TaskScheduler。 

private static Task CreateTaskWithTimeout(
    int xDelay, int yDelay, int taskDelay)
{
    var cts = new CancellationTokenSource();
    var token = cts.Token;
    var task = Task.Factory.StartNew(() =>
    {
        // Do some work, but fail if cancellation was requested
        token.WaitHandle.WaitOne(taskDelay);
        token.ThrowIfCancellationRequested();
        Console.WriteLine("Task complete");
    });

    var timerCts = new CancellationTokenSource();

    var messageTask = TaskEx.Delay(xDelay, timerCts.Token);
    messageTask.ContinueWith(t =>
    {
        // Display message at first timeout
        Console.WriteLine("X milliseconds elapsed");
    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    var cancelTask = TaskEx.Delay(yDelay, timerCts.Token);
    cancelTask.ContinueWith(t =>
    {
        // Display message and cancel task at second timeout
        Console.WriteLine("Y milliseconds elapsed");
        cts.Cancel();
    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    task.ContinueWith(t =>
    {
        timerCts.Cancel();
    });

    return task;
}

使用斯蒂芬·克利里的优秀 AsyncEx 库，你可以这样做：

TimeSpan timeout = TimeSpan.FromSeconds(10);

using (var cts = new CancellationTokenSource(timeout))
{
    await myTask.WaitAsync(cts.Token);
}

TaskCanceledException将在超时的情况下抛出。

解决此问题的另一个方法是使用无扩展：

public static Task TimeoutAfter(this Task task, TimeSpan timeout, IScheduler scheduler)
{
        return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

测试了上述使用以下在单元测试代码，它为我

TestScheduler scheduler = new TestScheduler();
Task task = Task.Run(() =>
                {
                    int i = 0;
                    while (i < 5)
                    {
                        Console.WriteLine(i);
                        i++;
                        Thread.Sleep(1000);
                    }
                })
                .TimeoutAfter(TimeSpan.FromSeconds(5), scheduler)
                .ContinueWith(t => { }, TaskContinuationOptions.OnlyOnFaulted);

scheduler.AdvanceBy(TimeSpan.FromSeconds(6).Ticks);

您可能需要以下命名空间：

using System.Threading.Tasks;
using System.Reactive.Subjects;
using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;
using Microsoft.Reactive.Testing;
using System.Threading;
using System.Reactive.Concurrency;

@凯文的回答的通用版本以上反应扩展。

public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, IScheduler scheduler)
{
    return task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

使用可选的调度程序：

public static Task<T> TimeoutAfter<T>(this Task<T> task, TimeSpan timeout, Scheduler scheduler = null)
{
    return scheduler == null 
       ? task.ToObservable().Timeout(timeout).ToTask() 
       : task.ToObservable().Timeout(timeout, scheduler).ToTask();
}

顺便说一句：当超时发生时，一个超时会抛出异常

如果您使用的是BlockingCollection安排任务，生产者可以运行可能长时间运行的任务，用户可以使用具有超时和取消标记内置的。

的TryTake方法

这是之前答案的略微增强版本。

  • 此外 劳伦斯的回答, ，超时时取消原来的任务。
  • 除了 sjb 的答案变体 2 和 3, ，你可以提供 CancellationToken 对于原始任务，当超时发生时，你得到 TimeoutException 代替 OperationCanceledException.
async Task<TResult> CancelAfterAsync<TResult>(Func<CancellationToken, Task<TResult>> startTask, TimeSpan timeout, CancellationToken cancellationToken)
{
    using (var timeoutCancellation = new CancellationTokenSource())
    using (var combinedCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCancellation.Token))
    {
        var originalTask = startTask(combinedCancellation.Token);
        var delayTask = Task.Delay(timeout, combinedCancellation.Token);
        var completedTask = await Task.WhenAny(originalTask, delayTask);
        // Cancel timeout to stop either task:
        // - Either the original task completed, so we need to cancel the delay task.
        // - Or the timeout expired, so we need to cancel the original task.
        // Canceling will not affect a task, that is already completed.
        timeoutCancellation.Cancel();
        if (completedTask == originalTask)
        {
            // original task completed
            return await originalTask;
        }
        else
        {
            // timeout
            throw new TimeoutException();
        }
    }
}

安德鲁·阿诺特的回答有几个变体：

  1. 如果您想等待现有任务并查明它是否已完成或超时，但不想在发生超时时取消它：

    public static async Task<bool> TimedOutAsync(this Task task, int timeoutMilliseconds)
{
    if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); }

    if (timeoutMilliseconds == 0) {
        return !task.IsCompleted; // timed out if not completed
    }
    var cts = new CancellationTokenSource();
    if (await Task.WhenAny( task, Task.Delay(timeoutMilliseconds, cts.Token)) == task) {
        cts.Cancel(); // task completed, get rid of timer
        await task; // test for exceptions or task cancellation
        return false; // did not timeout
    } else {
        return true; // did timeout
    }
}

  2. 如果要启动工作任务并在发生超时时取消工作： 

    public static async Task<T> CancelAfterAsync<T>( this Func<CancellationToken,Task<T>> actionAsync, int timeoutMilliseconds)
{
    if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); }

    var taskCts = new CancellationTokenSource();
    var timerCts = new CancellationTokenSource();
    Task<T> task = actionAsync(taskCts.Token);
    if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds, timerCts.Token)) == task) {
        timerCts.Cancel(); // task completed, get rid of timer
    } else {
        taskCts.Cancel(); // timer completed, get rid of task
    }
    return await task; // test for exceptions or task cancellation
}

  3. 如果您已经创建了一个任务，并且希望在发生超时时取消该任务： 

    public static async Task<T> CancelAfterAsync<T>(this Task<T> task, int timeoutMilliseconds, CancellationTokenSource taskCts)
{
    if (timeoutMilliseconds < 0 || (timeoutMilliseconds > 0 && timeoutMilliseconds < 100)) { throw new ArgumentOutOfRangeException(); }

    var timerCts = new CancellationTokenSource();
    if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds, timerCts.Token)) == task) {
        timerCts.Cancel(); // task completed, get rid of timer
    } else {
        taskCts.Cancel(); // timer completed, get rid of task
    }
    return await task; // test for exceptions or task cancellation
}

另外评论一下，这些版本如果没有发生超时就会取消定时器，所以多次调用不会导致定时器堆积。

sjb

我觉得Task.Delay()任务和CancellationTokenSource在其他的答案有点吃不消了我的使用情况下，紧上下的网络循环。

和虽然乔Hoag的上MSDN博客被激励制作一个Task.TimeoutAfter方法，我有点厌倦使用TimeoutException为出于同样的原因如上述流量控制的，因为超时被比不预期更频繁。

所以我决定用这个，也可以用来处理在博客中提到的优化：

public static async Task<bool> BeforeTimeout(this Task task, int millisecondsTimeout)
{
    if (task.IsCompleted) return true;
    if (millisecondsTimeout == 0) return false;

    if (millisecondsTimeout == Timeout.Infinite)
    {
        await Task.WhenAll(task);
        return true;
    }

    var tcs = new TaskCompletionSource<object>();

    using (var timer = new Timer(state => ((TaskCompletionSource<object>)state).TrySetCanceled(), tcs,
        millisecondsTimeout, Timeout.Infinite))
    {
        return await Task.WhenAny(task, tcs.Task) == task;
    }
}

一个实例的使用情况是这样：

var receivingTask = conn.ReceiveAsync(ct);

while (!await receivingTask.BeforeTimeout(keepAliveMilliseconds))
{
    // Send keep-alive
}

// Read and do something with data
var data = await receivingTask;
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top