关于 Task 简单梳理（C#）【并发编程系列_4】
〇、前言
Task 是微软在 .Net 4.0 时代推出来的，也是微软极力推荐的一种多线程的处理方式。
在 Task 之前有一个高效多线程操作类 ThreadPool，虽然线程池相对于 Thread，具有很多优势避免频繁创建和销毁线程等，但是线程池也有一些使用上的不便，比如不支持取消、完成、失败通知等，也不支持线程执行的先后顺序配置。
为了解决上述痛点，Task 诞生了。Task 就是站在巨人的肩膀上而生，它是基于 ThreadPool 封装。Task 的控制和扩展性很强，在线程的延续、阻塞、取消、超时等方面远胜于 ThreadPool。
本文将对 Task 进行一个详细的介绍。
一、任务如何创建和启动？
创建任务和执行任务是可以分离的，也可以同时进行。如下代码有四种开启任务的方式：
- 第一种：任务 t1 通过调用 Task 类构造函数进行实例化，但仅在任务 t2 启动后调用其 Start() 方法启动。【创建+未启动】
- 第二种：任务 t2 通过调用 TaskFactory.StartNew(Action<Object>, Object) 方法在单个方法调用中实例化和启动。【创建+启动】
- 第三种：任务 t3 通过调用 Run(Action) 方法在单个方法调用中实例化和启动。【创建+启动】
- 第四种：任务 t4 通过调用 RunSynchronously() 方法在主线程上同步执行。【创建+未启动】
static void Main(string[] args) { // 用于异步调用的委托函数，接受类型为 Object 的参数 Action<object> action = (object obj) => { // Task.CurrentId ：任务 ID // Thread.CurrentThread.ManagedThreadId ：线程 ID Console.WriteLine($"Task={Task.CurrentId}, obj={obj}, Thread={Thread.CurrentThread.ManagedThreadId}"); // throw new Exception(); }; // 【第一种】创建一个就绪，但【未启动】的任务，需要在后文通过 t1.Start() 启动 Task t1 = new Task(action, "甲"); // alpha：初始 // 【第二种】【创建并启动】一个任务 Task t2 = Task.Factory.StartNew(action, "乙"); // 占用主线程，等待任务 t2 完成 t2.Wait(); // 启动第一个任务 t1 t1.Start(); Console.WriteLine($"t1 已启动 (主线程 = {Thread.CurrentThread.ManagedThreadId})"); // 通过 Wait() 占用主线程，等待 t1 执行完毕 t1.Wait(); // 【第三种】通过 Task.Run() 【创建并启动】一个任务 string taskData = "丙"; Task t3 = Task.Run(() => { Console.WriteLine($"Task={Task.CurrentId}, obj={taskData}, Thread={Thread.CurrentThread.ManagedThreadId}"); }); // 通过 Wait() 占用主线程，等待 t3 执行完毕 t3.Wait(); // 【第四种】创建一个就绪，但【未启动】的任务 t4 Task t4 = new Task(action, "丁"); // Synchronously：同步的 // 开启同步任务 t4，在主线程上运行 t4.RunSynchronously(); // t4 是以同步的方式运行的，此时的 Wait() 可以捕捉到异常 t4.Wait(); Console.ReadLine(); }
如下图输出结果，最先开启的 t2，由于是工厂中启动的，所以不占用主线程运行。Task.Run() 同样是非主线程运行，但它并未新开线程，而是直接用了 t2 执行的线程。
线程编号为 1 的是主线程，t1 是主线程最先创建的，所以直接由主线程运行。t4 是在同步执行的任务，因此也是主线程来执行。
二、等待一个或多个任务
用于等待任务的方法有很多个，如下：
| Wait() | task1.Wait() | 单线程等待 |
| WaitAll() | Task.WaitAll(tasks) | 等待任务集合 tasks 中的全部任务完成 |
| WaitAny() | int index = Task.WaitAny(tasks) | 等待任一任务完成，并返回这一任务的编号 |
| WhenAll() | Task t = Task.WhenAll(tasks) | 返回一个新的任务，这个任务的完成状态在【tasks 集合中全部任务都完成时】完成 |
| WhenAny() | Task t = Task.WhenAny(tasks) | 返回在任务集合 tasks 中第一个执行完成的任务对象 |
下面几个示例来实操下。
2.1 Wait()
对于 Wait() 单线程等待，没啥好说的，看代码：
static void Main(string[] args) { // 创建并执行一个任务执行匿名函数 Task taskA = Task.Run(() => Thread.Sleep(2000)); Console.WriteLine($"taskA Status: {taskA.Status}"); // taskA Status: WaitingToRun try { taskA.Wait(1000); // 主线程等待任务 1s 此时任务尚未完成 Console.WriteLine($"taskA Status: {taskA.Status}"); // taskA Status: Running taskA.Wait(); // 线程等待任务 taskA 完成 Console.WriteLine($"taskA Status: {taskA.Status}"); // taskA Status: RanToCompletion } catch (AggregateException) { Console.WriteLine("Exception in taskA."); } }
2.2 Wait(Int32, CancellationToken) 支持手动取消
关于 Wait(Int32, CancellationToken) 任务可手动取消的重载。在任务完成之前，超时或调用了 Cancel() 方法，等待终止。
如下示例，一个线程一个任务，线程中将 CabcellationTokenSource 的实例 cts 取消掉，导致后续任务等待时调用 cts.Token 导致异常 OperationCanceledException 的发生。
static void Main(string[] args) { CancellationTokenSource cts = new CancellationTokenSource(); Thread thread = new Thread(CancelToken); // 新开一个线程执行方法：CancelToken() thread.Start(cts); Task t = Task.Run(() => // 新增一个任务执行匿名函数 { Task.Delay(5000).Wait(); // 延迟等待 5s Console.WriteLine("Task ended delay..."); }); try { Console.WriteLine($"About to wait completion of task {t.Id}"); // 以上两个操作都有延迟，所以此处消息先打印 // 等待任务 t 1.51s，保证线程已执行完成，就是保证 CancellationTokenSource 已执行过取消操作 // 由于 cts 已经取消，因此次数就抛异常：OperationCanceledException bool result = t.Wait(1510, cts.Token); // 后边代码就不再执行，直接跳到 catch Console.WriteLine($"Wait completed normally: {result}"); Console.WriteLine($"The task status: {t.Status}"); } catch (OperationCanceledException e) { Console.WriteLine($"{e.GetType().Name}: The wait has been canceled."); Console.WriteLine($"Task status：{t.Status}"); // 此时程序运行 1.5s 多，任务 t 还在等待，因此状态是 Running Thread.Sleep(4000); // 4s + 1.5s > 5s 此时任务 t 已经执行完成，状态为 RanToCompletion Console.WriteLine("After sleeping, the task status: {t.Status}"); cts.Dispose(); } Console.ReadLine(); } private static void CancelToken(Object obj) { Thread.Sleep(1500); // 延迟 1.5s Console.WriteLine($"Canceling the cancellation token from thread {Thread.CurrentThread.ManagedThreadId}..."); CancellationTokenSource source = obj as CancellationTokenSource; if (source != null) source.Cancel(); // 将 CancellationTokenSource 的实例执行取消 }
2.3 WaitAll()
等待一组任务全部完成，无论是否抛异常。AggregateException 将会收集全部异常信息，可以通过遍历获取每一个异常详情。
如下代码，新建是个任务组成任务组 tasks，其中 2~5 线程手动抛异常，最后通过遍历 AggregateException aex 记录全部异常。
static void Main(string[] args) { var tasks = new List<Task<int>>(); // 创建一个委托，用于任务执行，并记录每个任务信息 Func<object, int> action = (object obj) => { int i = (int)obj; // 让每次的 TickCount 不同（系统开始运行的毫秒数） Thread.Sleep(i * 1000); if (2 <= i && i <= 5) // 从第 2 到 5 个任务都抛异常 { throw new InvalidOperationException("SIMULATED EXCEPTION"); } int tickCount = Environment.TickCount; // 获取系统开始运行的毫秒数 Console.WriteLine($"Task={Task.CurrentId}, i={i}, TickCount={tickCount}, Thread={Thread.CurrentThread.ManagedThreadId}"); return tickCount; }; // 连续创建 10 个任务 for (int i = 0; i < 10; i++) { int index = i; tasks.Add(Task<int>.Factory.StartNew(action, index)); // 后台线程 } try { // WaitAll() 等待全部任务完成 Task.WaitAll(tasks.ToArray()); // 由于线程中手动抛出了异常，因此这个消息将无法打印在控制台 Console.WriteLine("WaitAll() has not thrown exceptions. THIS WAS NOT EXPECTED."); } catch (AggregateException aex) // AggregateException 异常中包含 2~5 四个异常 { Console.WriteLine("\nThe following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)"); Console.WriteLine($"\ne.InnerExceptions.Count：{aex.InnerExceptions.Count}"); for (int j = 0; j < aex.InnerExceptions.Count; j++) // aex.InnerExceptions.Count == 4 { Console.WriteLine("\n-------------------------------------------------\n{0}", aex.InnerExceptions[j].ToString()); } } Console.ReadLine(); }
2.4 WaitAny()
等待一组任务中的任一任务完成，然后返回第一个执行完成任务的序号，可通过tasks[index].Id取得任务 ID。
如下示例，每个任务都有延迟，当第一个任务完成时，遍历打印出其他全部任务的状态：
static void Main(string[] args) { Task[] tasks = new Task[5]; for (int ctr = 0; ctr <= 4; ctr++) { int factor = ctr; // 重新声明一个变量 tasks[ctr] = Task.Run(() => Thread.Sleep(factor * 250 + 50)); } int index = Task.WaitAny(tasks); // 等待任一任务结束 Console.WriteLine($"任务 #{tasks[index].Id} 已完成。"); Console.WriteLine("\n当前各个任务的状态："); foreach (var t in tasks) Console.WriteLine($" Task {t.Id}: {t.Status}"); Console.ReadLine(); }
参考：https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.wait?view=net-7.0
三、延续任务 Task.ContinueWith()
3.1 一个简单的示例
如下代码，首先创建一个耗时的任务 task 并启动，此时也不影响主线程的运行。然后通过task.ContinueWith()在第一个任务执行完成后，执行其中的匿名函数。
static void Main(string[] args) { // 创建一个任务 Task<int> task = new Task<int>(() => { int sum = 0; Console.WriteLine($"使用 Task 执行异步操作，当前线程 {Thread.CurrentThread.ManagedThreadId}"); Thread.Sleep(2000); for (int i = 0; i < 100; i++) { sum += i; } return sum; }); // 启动任务 task.Start(); // 主线程在此处可以执行其他处理 Console.WriteLine($"1 主线程 {Thread.CurrentThread.ManagedThreadId}"); Thread.Sleep(1000); //任务完成时执行处理。 Task cwt = task.ContinueWith(t => { Console.WriteLine($"任务完成后的执行结果：{t.Result} 当前线程 {Thread.CurrentThread.ManagedThreadId}"); }); task.Wait(); cwt.Wait(); Console.WriteLine($"2 主线程 {Thread.CurrentThread.ManagedThreadId}"); Console.ReadLine(); }
详情可参考：https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.continuewith?view=net-7.0
3.2 任务的并行与串行
ContinueWith、WaitAll 当这两者结合起来，我们就可以处理复杂一点的东西。比如，现在有 7 个任务，其中 t1 需要串行，t2-t3 可以并行，t4 需要串行，t5-t6 并行，t7 串行。逻辑如下图：
public static void Main(string[] args) { ConcurrentStack<int> stack = new ConcurrentStack<int>(); // ConcurrentStack：线程安全的后进先出(LIFO：LastIn-FirstOut)集合 ConcurrentBag<int> bag = new ConcurrentBag<int>(); // ConcurrentBag：线程安全的无序集合 // t1先串行 var t1 = Task.Factory.StartNew(() => { stack.Push(1); stack.Push(2); }); // t1.ContinueWith() t1 之后，t2、t3并行执行 var t2 = t1.ContinueWith(t => { int result; stack.TryPop(out result); }); // t2,t3并行执行 var t3 = t1.ContinueWith(t => { int result; stack.TryPop(out result); }); // 等待 t2、t3 执行完 Task.WaitAll(t2, t3); //t4串行执行 var t4 = Task.Factory.StartNew(() => { stack.Push(1); stack.Push(2); }); // t5、t6 并行执行 var t5 = t4.ContinueWith(t => { int result; stack.TryPop(out result); }); // t5、t6 并行执行 var t6 = t4.ContinueWith(t => { int result; // 只弹出，不移除 stack.TryPeek(out result); }); // 临界区：等待 t5、t6 执行完 Task.WaitAll(t5, t6); // t7 串行执行 var t7 = Task.Factory.StartNew(() => { Console.WriteLine($"当前集合元素个数：{stack.Count}"); // 当前集合元素个数：1 }); Console.ReadLine(); }
四、为什么性能方面 Task > ThreadPool ？
ThreadPool 使用的是线程池全局队列，全局队列中的线程依旧会存在竞争共享资源的情况，从而影响性能。
Task 基于 ThreadPool 实现，相当于 ThreadPoll 的优化版。它不再使用线程池的全局队列，而是使用的本地队列，使线程之间的资源竞争减少。同时 Task 提 供了丰富的 API 来管理线程、控制。
但是相对 Thread 和 ThreadPool 的内存方面的消耗，Task 依赖于 CPU 对于多核的 CPU 性能就更强了，单核的 CPU 三者的性能没什么差别。推荐参考：关于线程池和队列
参考： https://www.cnblogs.com/huangxincheng/archive/2012/04/03/2430638.html
https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task?view=net-7.0
本文来自博客园，作者：橙子家，欢迎微信扫码关注博主【橙子家czzj】，有任何疑问欢迎沟通，共同成长！
转载本文请注明原文链接：https://www.cnblogs.com/hnzhengfy/p/task.html
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步