目录

一、需求

二、Task取消任务

三、Task取消任务的回调

四、Task超时处理的实现

五、其他的写法

结束

一、需求

在之前的帖子中，介绍了 async / await 的用法，所以新的问题又来了，如果调用异步方法后，异步方法一直不给返回结果怎么办？这时线程还会一直卡住无法动弹，如果你用的是多线程（Task.Run 或者 Thread）可能感受不到，如果在 Winform 的 UI 线程下执行你就知道了，界面卡住完全无法操作，要解决这个问题，这就知道怎么取消任务了，添加一个任务后，要固定时间内返回结果，如果超时就取消任务，并且在多个任务同时执行的时候，依然按顺序来执行，这就是本文章要实现的效果。

二、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)
            {
            }
        }
    }
}

运行：

上面代码中，使用  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
            {
                Thread.Sleep(3000);
                Console.WriteLine("等待结束");
                source.Token.ThrowIfCancellationRequested();
            }
            catch (OperationCanceledException)
            {
            }
        }
    }
}

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

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

如果你有一些 C# 基础，就很容易看出代码有多少问题了，问题如下：

1.CancellationTokenSource 的用法不对

ThrowIfCancellationRequested() 方法在执行后会检查 CancellationToken 是否已经有取消请求。如果有取消请求，这个方法会抛出一个 OperationCanceledException 异常，用来停止当前的操作。

但是当前延时等待，并没有使用任何的 Token ，并且在执行 source.Token.ThrowIfCancellationRequested() 这句代码的时候，等待结束这句已经执行了，所以此时取消没有任何意义。

2.catch 接收部分没有任何的代码

即使 source.Token.ThrowIfCancellationRequested() 这里抛出了异常，也是什么都看不到。

3.Thread.Sleep 不支持传入参数 source.Token

代码如下：

根据他们的例子，使用 Thread.Sleep 进行线程睡眠，为了实现超时取消的效果，在任务中必须加入 for 或者 while 循环，并且在下一轮循环中，执行 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();
        }
    }
}

 运行：

在这里依然是不推荐上面的写法，主要目的还是为了展示 CancellationTokenSource  的一些用法，告诉你 CancellationTokenSource 有这么一个东西，但是，当前的案例绝对不是一个好的案例。

四、Task超时处理的实现

在 C# 的开发中，我强烈推荐多使用 “异步” 去取代 Thread，使用异步实现超时处理非常的简单。

代码：

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

# c#
Logo
技术共进，成长同行——讯飞AI开发者社区

技术共进，成长同行——讯飞AI开发者社区

更多推荐

机器学习与人工智能

网络爬虫（Web Crawler）是一种按照特定规则自动抓取互联网信息的程序。它可以自动化地浏览网络、下载内容并提取有价值的数据，广泛应用于搜索引擎、数据分析和商业智能等领域。

avatar 讯飞AI开发者社区
cover

沙利文：AI赋能千行百业白皮书｜附30页PDF文件下载

avatar 讯飞AI开发者社区
cover

强烈推荐：智能体强化学习：解锁大语言模型自主决策能力的终极指南（含500+研究总结）

avatar 讯飞AI开发者社区