异步方法和TPL： async / await / Parallel

封装

咱们要把上面这个Task封装成方法，怎么办？

最重要的一点，这个方法要能返回生成的random，后面的代码要用！

public static Task<int> getRandom() { return Task<int>.Run(() => { Thread.Sleep(500); //模拟耗时 return new Random().Next(); }); }

@想想@：应该如何调用这个方法？（_提示：不要直接__getRandom().Result_）

假如咱们还须要进一步的封装，添加一个方法Process，里面调用getRandom()并把其结果输出：

public static void Process() { Task<int> task = getRandom(); Console.WriteLine(task.Result); }

故技重施，好像不行了，此次……

@想想@：再让Process()返回Task行不行？一个Task套另外一Task会出现什么状况？

在getRandom()和Process()中展现线程Id看一看：

Console.WriteLine("in getRandom() with Thread-" + Thread.CurrentThread.ManagedThreadId);

在.NET core的I/O类库中，咱们会发现这样的方法：

public static Task AppendAllLinesAsync(string path, IEnumerable<string> contents, Encoding encoding, CancellationToken cancellationToken = default); public static Task<byte[]> ReadAllBytesAsync(string path, CancellationToken cancellationToken = default);

注意：

• 方法名被添加了Async后缀（推荐命名规范）
• 方法的返回类型为Task或Task<T>

异步方法

.NET为咱们提供了简洁优雅的异步方法，只须要两个关键字：

async 和 await

被async标记的方法被称为异步方法，

• 可是，async不必定（没有强制力保证）异步。同步的方法同样能够标记async。async的做用只是：
• 告诉编译器方法中能够出现await。若是只有async没有await，报编译时警告

只有await没有async，报编译错误。

static async void Process() { int random = await getRandom(); Console.WriteLine(random); }

await，能够理解为：异步（async）等待，后接 awaitable 实例。

咱们能够简单的把awaitable理解成Task。

非阻塞等待

异步方法一直同步运行，直到 await。

从 await 开始异步（分叉）：

• 执行 awatable 中的内容，同时
• 返回方法的调用处，执行其后内容

直到 awaitable 中内容执行完毕，才暂停方法调用处内容，继续执行await以后的代码。

异步方法执行完毕，继续方法调用处内容。

以上述代码为例：

//33 --> 44 --> 45 --> 46 --> 47 --> 调用异步方法处 // +--> 52 --> 57-- + 被调用异步方法 // +--> 35 --> 38 +--> 39 awaitable

注意：若是52行以前还有普通（非异步）代码，这些代码不会被异步执行。

await不像Wait()或Result同样，

开始（但不是当即或同步的）
async和await会不会开启一个新的任务（或者线程）？不会。

异步方法分为两种：

返回 void 或 Task

public static async void Getup() { Console.WriteLine($"before await-1 with thread {Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"before await-2 with thread {Thread.CurrentThread.ManagedThreadId}"); //await 以前的代码，在主线程上运行 // await Task.Run(()=> { Console.WriteLine($"in await with thread {Thread.CurrentThread.ManagedThreadId}"); }); // Console.WriteLine($"after await-3 with thread {Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"after await-4 with thread {Thread.CurrentThread.ManagedThreadId}"); }

从await开始，代码开始分叉（只是异步，不必定新开线程）：

• 一边执行await后的表达式（Task）
• 一边返回到方法调用者处继续执行

直到await后的Task执行完毕，才会返回async方法，继续执行其await（非阻塞）以后的剩余代码。

Console.WriteLine($"before async-1 with thread {Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"before async-2 with thread {Thread.CurrentThread.ManagedThreadId}"); Getup(); for (int i = 0; i < 10; i++) { //Getup()里await部分的运行，会打乱这里代码的同步运行 Console.WriteLine($"after async-{3 + i} with thread {Thread.CurrentThread.ManagedThreadId}"); }

实质上，await采用的是Task的ContinueWith()机制：await 以后的方法内代码，被 await Task 执行完毕后调用。

对比演示：

• 非异步方法：只有Task异步执行
• 调用Wait()的非异步方法：Wait()会阻塞当前线程进行等待

异步方法中的 void 能够被直接替换成 Task（推荐），以便于该方法进一步的被 await 传递。

void一般作为顶级（top-level）方法使用。

思考：当async方法中抛出异常，void方法和Task方法的区别？

返回Task<T>

返回值被Task包裹，写成Task<T>，T指方法体内声明返回的类型

//方法的声明：返回的是Task<int> public static async Task<int> Getup() { int result = await Task<int>.Run(() => { Thread.Sleep(500); Console.WriteLine($"at await in Getup() with thread {Thread.CurrentThread.ManagedThreadId}"); return new Random().Next(); }); //方法体内，返回的是int return result; }

特别注意：不能直接Getup().Result 或 await Getup()取值，不然……

思考：和直接返回Task<T>的区别？

任务并行库（Task Parallel Library）

.NET中System.Threading 和System.Threading.Tasks名称空间下的类库

简化异步/并行开发，在底层实现：

• 动态调整并行规模
• 处理分区
• 线程（池）调度（器）等……

基于Task的并行

最简单的例子，Parallel.Invoke()：

for (int i = 0; i < 5; i++) { Console.WriteLine(); Parallel.Invoke( () => { Console.WriteLine(i + $":task-{Task.CurrentId} in thread-{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"task-{Task.CurrentId} begin in thread-{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"task-{Task.CurrentId} in thread-{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"task-{Task.CurrentId} end in thread-{Thread.CurrentThread.ManagedThreadId}"); }, () => { Console.WriteLine(i + $":task-{Task.CurrentId} in thread-{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"task-{Task.CurrentId} in begin in thread-{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"task-{Task.CurrentId} in thread-{Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine($"task-{Task.CurrentId} in end in thread-{Thread.CurrentThread.ManagedThreadId}"); } ); }

其余方法：

• For循环

  Parallel.For(0, 10, x => { Console.WriteLine(x); });

• ForEach

  Parallel.ForEach(Enumerable.Range(1,10), x => Console.WriteLine(x));

引入线程数组：Task[]

• WaitAll / WaitAny：
• WhenAll / WhenAny：

对比如下代码，体会 await 的 continuation：

public static async Task Getup() { //await Task.Run(() => { Console.WriteLine("洗脸"); }); //await Task.Run(() => { Console.WriteLine("刷牙"); }); //await Task.Run(() => { Console.WriteLine("吃早餐"); }); //await Task.Run(() => { Console.WriteLine("背单词"); }); Task[] tasks = { Task.Run(() => { Console.WriteLine("洗脸"); }), Task.Run(() => { Console.WriteLine("刷牙"); }), Task.Run(() => { Console.WriteLine("吃早餐"); }), Task.Run(() => { Console.WriteLine("背单词"); }) }; await Task.WhenAll(tasks); }

补充：

Delay()

FromResult()

AsyncState

并行Linq Parallel LINQ (PLINQ)

仅适用于Linq to Object，主要的措施是：对数据源进行分区，而后多核并发运行（保守模式：若是能不并发就不并发）

核心方法：AsParallel()，在数据源后添加。

try { IEnumerable<int> numbers = Enumerable.Range(0, 1000); var filtered = numbers.AsParallel() //.Where(n => n % 11 == 0) .Where(n => 8 % (n > 100 ? n : 0) == 0) ; filtered.ForAll(f => Console.WriteLine(f)); } catch (AggregateException ae) { ae.Handle(e => { Console.WriteLine(e); return true; }); }

ForAll()：一样能够并发执行

仍然是AggregateException异常

最佳实践

使用异步/并行的反作用（side effect）：

1. 增长代码的复杂性（尤为是bug调试）
2. 异步/并行的切换须要消耗额外的资源

简单理解：

• 锁、死锁（Deadlock）、资源争夺（race condition）
• 线程安全 （Thread Safty）
• 天下没有免费的午饭
• 越是复杂精巧的东西越不“耐操”（健壮性robust）

老是最后考虑异步/并行：（我的建议）

• 老是在最后考虑异步/并发（尤为是B/S架构）
• 肯定性能瓶颈
• 肯定该瓶颈能够经过异步/并行的方法解决