C# async / await 任务超时处理

熊思宇

已于 2024-07-13 17:19:25 修改

阅读量9k

点赞数 8

分类专栏： C# 文章标签： c#

于 2022-11-19 16:19:12 首次发布

本文链接：https://blog.csdn.net/qq_38693757/article/details/127935673

版权

C# 专栏收录该内容

75 篇文章 79 订阅

订阅专栏

一、需求

在之前的帖子中，介绍了 async / await 的用法，那么新的问题又来了，如果调用一个异步方法后，一直不给返回值结果怎么办呢？这就涉及到怎么取消任务了。添加一个任务后，如果固定时间内没用返回结果，那么就取消执行，并且在多个任务同时执行的时候，依然按顺序来执行，这就是本文章要实现的效果。

二、Task取消任务

在 C# 以前的2.0 等版本中，线程是可以强制终止的，在后面的版本中，就不允许强制去结束线程的，后面微软就提供了一个 CancellationTokenSource 相关的接口开源取消任务。于是我搜索了大量的帖子，一看全是各种抄袭，相互抄来抄去的，看的我血压飙升，完全是浪费时间，总结取消的方法如下：

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

namespace 超时测试
{
    internal class Program
    {
        static CancellationTokenSource source = new CancellationTokenSource();
        static void Main(string[] args)
        {
            Task.Run(() => Test());
            Thread.Sleep(1000);
            Console.WriteLine("取消任务");
            source.Cancel();

            Console.ReadKey();
        }

        static void Test()
        {
            try
            {
                int index = 0;
                for (int i = 0; i < 10; i++)
                {
                    Thread.Sleep(200);
                    source.Token.ThrowIfCancellationRequested();
                    Console.WriteLine("执行次数：{0}", index++);
                }
            }
            catch (OperationCanceledException)
            {
            }
        }
    }
}

运行：

这个可以取消任务是吧，那下面换一个写法：

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

namespace 超时测试
{
    internal class Program
    {
        static CancellationTokenSource source = new CancellationTokenSource();
        static void Main(string[] args)
        {
            Task.Run(() => Test());
            Thread.Sleep(1000);
            Console.WriteLine("取消任务");
            source.Cancel();

            Console.ReadKey();
        }

        static void Test()
        {
            try
            {
                Thread.Sleep(3000);
                Console.WriteLine("等待结束");
                source.Token.ThrowIfCancellationRequested();
            }
            catch (OperationCanceledException)
            {
            }
        }
    }
}

任务中等待三秒，我在等待一秒后取消任务，看看结果：

明明在执行一秒后取消了任务，但结果 “等待结束” 却依然执行了。

由于 Thread.Sleep 并不支持传入参数 source.Token，根据他们写的例子，可以总结一点：使用 Thread.Sleep 进行线程睡眠，如果要想用 Cancel 取消任务，在任务中必须加入 for 或者 while 循环，并且在下一轮循环中，执行到 source.Token.ThrowIfCancellationRequested() 这句会抛出一个异常，后续代码会自动取消执行，然后错误会在 try 的 catch 语句内接收。

换个写法，我在 while 循环中加入一个判断，如果等于 true，直接跳出循环，这不也可以中断任务，如下：

namespace 取消任务4
{
    internal class Program
    {
        static void Main(string[] args)
        {
            bool isOut = false;

            var task1 = Task.Run(() =>
            {
                for (int i = 0; i < 100; i++)
                {
                    if (isOut) return;

                    Console.WriteLine("执行中" + i);
                    Thread.Sleep(500);
                }
            });

            Thread.Sleep(2000);
            Console.WriteLine("取消任务");
            isOut= true;

            Console.ReadKey();
        }
    }
}

运行：

三、Task取消任务的回调

根据上节的写法，取消任务也是可以加入回调的，如下：

namespace 取消任务2
{
    internal class Program
    {
        static CancellationTokenSource source = new CancellationTokenSource();

        static void Main(string[] args)
        {
            var task1 = Task.Run(() =>
            {
                for (int i = 0; i < 100; i++)
                {
                    source.Token.ThrowIfCancellationRequested();
                    Console.WriteLine("执行中" + i);
                    Thread.Sleep(500);
                }
            }, source.Token);

            //在指定的毫秒数后取消task执行
            source.CancelAfter(2 * 1000);

            //取消任务后的回调
            source.Token.Register(() =>
            {
                //不延迟会获取不到正确的状态
                Thread.Sleep(50);
                Console.WriteLine("task1状态：" + task1.Status);
                Console.WriteLine("IsFaulted状态：" + task1.IsFaulted);//由于未处理的异常，任务已完成。
                Console.WriteLine("IsCompleted状态：" + task1.IsCompleted);//获取一个值，该值指示任务是否已完成。
            });

            Console.ReadKey();
        }
    }
}

运行：

四、Task超时处理的实现

虽然 Thread.Sleep 并不支持传入 Token，但在异步编程中是可以实现的。

我们先来一个超时取消后续代码执行的方法：

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

namespace 超时测试
{
    internal class Program
    {
        static CancellationTokenSource Cancellation = new CancellationTokenSource();
        static void Main(string[] args)
        {
            //设置超时的时间
            Cancellation.CancelAfter(TimeSpan.FromSeconds(1));

            Task.Run(async () =>
            {
                try
                {
                    Console.WriteLine("方法执行开始");
                    await Task.Delay(3000, Cancellation.Token);
                    Console.WriteLine("方法执行结束");
                }
                catch (OperationCanceledException)
                {
                    Console.WriteLine("取消操作");
                }
            });

            Console.ReadKey();
        }
    }
}

运行：

在上面我们设置的超时时间是1秒，等待为3秒，超时后，就自动抛出异常了，所以 Console.WriteLine("方法执行结束") 这句代码并没有执行，这就是我们想要的效果了。

接下来把超时时间改为3秒，等待时间改为1秒，看看效果：

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

namespace 超时测试
{
    internal class Program
    {
        static CancellationTokenSource Cancellation = new CancellationTokenSource();
        static void Main(string[] args)
        {
            //设置超时的时间
            Cancellation.CancelAfter(TimeSpan.FromSeconds(3));

            Task.Run(async () =>
            {
                try
                {
                    Console.WriteLine("方法执行开始");
                    await Task.Delay(1000, Cancellation.Token);
                    Console.WriteLine("方法执行结束");
                }
                catch (OperationCanceledException)
                {
                    Console.WriteLine("取消操作");
                }
            });

            Console.ReadKey();
        }
    }
}

运行：

那么超时取消代码执行的效果就实现了。

五、其他的写法

下面代码是各种超时取消的写法，我全部放一个类里面了，根据自己的需求看看那些是可以用的，具体我也没怎么仔细的测试，可能会有 bug，不要复制了就直接拿去用。

代码：

namespace 异步编程1
{
    public static class Lib1
    {
        public static async Task<TResult?> TimeoutAfter<TResult>(this Task<TResult> task, int timeout)
        {
            using (var cancelToken = new CancellationTokenSource())
            {
                Task completedTask = await Task.WhenAny(task, Task.Delay(timeout, cancelToken.Token));
                if (completedTask == task)
                {
                    cancelToken.Cancel();
                    return await task;
                }
                else
                {
                    // 超时处理
                    Console.WriteLine("超时了");
                    return default;
                }
            }
        }

        public static async Task<bool> OnTimeout<T>(T t, Action<T> action, int waitms) where T : Task
        {
            if (!(await Task.WhenAny(t, Task.Delay(waitms)) == t))
            {
                action(t);
                return true;
            }
            else
            {
                return false;
            }
        }

        public static async Task<bool> TryWithTimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout, Action<TResult> successor)
        {
            using var timeoutCancellationTokenSource = new CancellationTokenSource();
            var completedTask = await Task.WhenAny(task, Task.Delay(timeout, timeoutCancellationTokenSource.Token)).ConfigureAwait(continueOnCapturedContext: false);

            if (completedTask == task)
            {
                timeoutCancellationTokenSource.Cancel();

                // propagate exception rather than AggregateException, if calling task.Result.
                var result = await task.ConfigureAwait(continueOnCapturedContext: false);
                successor(result);
                return true;
            }
            else
                return false;
        }

        public static async Task<bool> BeforeTimeout(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;
            }
        }
    }
}

结束

如果这个帖子对你有所帮助，欢迎关注、点赞、留言

end

熊思宇

关注

8
点赞
踩
51

收藏

觉得还不错? 一键收藏
打赏
2
评论
C# async / await 任务超时处理

在 C# 以前的2.0 等版本中，线程是可以强制终止的，到了后面，就不允许强制去结束线程的，后面微软就提供了一个 CancellationTokenSource 相关的接口开源取消任务。添加一个任务后，如果固定时间内没用返回结果，那么就取消执行，并且在多个任务同时执行的时候，依然按顺序来执行，这就是本文章要实现的效果。可以看到，方法执行结束这段代码并没有打印，这就是我们想要的效果了，在上面我们设置的超时时间是1秒，在后面的执行中，使用了线程睡眠时间是2秒，超时后，就自动取消操作了。
复制链接

扫一扫