关于 Task 简单梳理（C#）【并发编程系列_4】

关于 Task 简单梳理（C#）【并发编程系列_4】

 

阅读目录

• 〇、前言
• 一、任务如何创建和启动？
• 二、等待一个或多个任务
  • 2.1 Wait()
  • 2.2 Wait(Int32, CancellationToken)  支持手动取消
  • 2.3 WaitAll()
  • 2.4 WaitAny()
• 三、延续任务 Task.ContinueWith()
  • 3.1 一个简单的示例
  • 3.2 任务的并行与串行
• 四、为什么性能方面 Task > ThreadPool ？

---

回到顶部

〇、前言

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

https://www.cnblogs.com/zhaoshujie/p/11082753.html

本文来自博客园，作者：橙子家，微信号：zfy1070491745，有任何疑问欢迎沟通，一起成长！ 您的支持，博主的动力！