关于c++:异步方法和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架构）
• 确定性能瓶颈
• 确定该瓶颈能够通过异步/并行的办法解决