0%

C#杂记之肆:异步

前方高能!
这篇笔记断断续续花了近10天,思路、结构较为混沌,如果没有充分做好心理准备,建议立刻关闭窗口。
(其实就是我写完实在不愿审阅)

首先说明,异步是极为高深的高级编程技术,这篇文章只是才疏学浅的我阅读文档之后的一些思考与理解,可能有极多描述不准确乃至完全错误之处,还望批评指导。顺便吐槽,C#文档翻译得实在是太烂了,很多地方一看就是机翻的,却没有机翻警告。很多地方百思不得其解的词,切换到英语就发现其实很简单,翻译的用词完全错误,难受啊!

何为异步

与异步相对的是“同步”,代表着一句代码的执行结束是其后一句代码的执行开始,整个流程是按照固定的顺序进行的,这是一般程序的逻辑。然而,某些语句可能需要花较长时间才能得到结果——比如网络通信和文件读写——这些语句的执行并不怎么占用CPU,但会阻塞整个线程,后续的语句需要等待这些语句执行完成,造成大量的浪费。特别是如果网络环境很不好、读取的文件好几个G,那可是尤其要命,可能整个程序都会出现肉眼可见的卡顿甚至崩溃。

为了解决这种飞快的CPU与龟爬的IO之间的不平衡,传统的方案是单独开个线程让它去执行耗时的操作,让主线程继续运行与耗时操作的结果无关的代码。但是线程操作很麻烦、开销很高,线程数量也有限,不是能随便使用的,所以依然不是个完美的方法。

异步就是为了解决这个问题而存在的。当代码需要执行一个耗时的操作时,它只发出指令,并不等待结果,然后就去执行其他代码了。一段时间后,当耗时操作返回结果时,再通知CPU进行处理。

怎么使用

从C# 5开始,编写异步程序变得比较容易。

C#的异步编程模型主要通过两个关键字来使用:asyncawait

用早餐毁掉美好的一天

先来一段同步的憨憨代码,这描述了一个“做早餐”的流程:

  1. 倒一杯咖啡。
  2. 加热平底锅,然后煎两个鸡蛋。
  3. 煎三片培根。
  4. 烤两片面包。
  5. 在烤面包上加黄油和果酱。
  6. 倒一杯橙汁。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static void Main(string[] args)
{
Coffee cup = PourCoffee(); //倒咖啡
Console.WriteLine("coffee is ready");
Egg eggs = FryEggs(2); //煎蛋
Console.WriteLine("eggs are ready");
Bacon bacon = FryBacon(3); //煎培根
Console.WriteLine("bacon is ready");
Toast toast = ToastBread(2); //烤面包
ApplyButter(toast); //涂黄油
ApplyJam(toast); //涂果酱
Console.WriteLine("toast is ready");
Juice oj = PourOJ(); //倒橙汁
Console.WriteLine("oj is ready");

Console.WriteLine("Breakfast is ready!");
}

线性的逻辑很简单,但有大问题。煎蛋、煎培根和烤面包都要花很长时间,其实完全可以在做煎蛋和培根的同时,让面包自己在面包机里烤。不然还没等面包烤完,别的东西早凉透了,吃了可能还会引起肠胃不适。煎蛋和煎培根甚至也没必要一前一后——谁家还没有两个锅呢?或者找个大点的锅来一起煎也行啊。

异步做早餐

来看看一个近乎完美的“做早餐解决方案”是怎样的。下面是C#文档里的示范异步代码,我擅自添加了些方便理解的沙雕注释:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
static async Task Main(string[] args)
{
Coffee cup = PourCoffee(); //倒杯咖啡
Console.WriteLine("coffee is ready");
var eggsTask = FryEggsAsync(2); //得煎俩鸡蛋,开整!
var baconTask = FryBaconAsync(3); //得煎仨培根,开整!
var toastTask = MakeToastWithButterAndJamAsync(2); //得搞两片涂黄油和果酱的面包,开整!

var allTasks = new List<Task>{eggsTask, baconTask, toastTask}; //列个任务清单吧
while (allTasks.Any()) //看来清单里还有任务没搞完
{
Task finished = await Task.WhenAny(allTasks); //下一个完成的任务是啥?
if (finished == eggsTask) //噢,是鸡蛋煎好了!
{
Console.WriteLine("eggs are ready");
}
else if (finished == baconTask) //噢,是培根煎好了!
{
Console.WriteLine("bacon is ready");
}
else if (finished == toastTask) //噢,是面包做完了!
{
Console.WriteLine("toast is ready");
}
allTasks.Remove(finished); //行,把完成的任务从清单里划了
}
Juice oj = PourOJ(); //最后再来杯橙汁,完事
Console.WriteLine("oj is ready");
Console.WriteLine("Breakfast is ready!"); //爽到

async Task<Toast> MakeToastWithButterAndJamAsync(int number)
{
var toast = await ToastBreadAsync(number); //要处理面包得先等面包烤好
ApplyButter(toast); //涂点黄油
ApplyJam(toast); //涂点果酱
return toast;
}
}

粗略一看,握草,感觉魔改成异步之后复杂了好多。其实不然,我慢慢来分析。

定义异步方法

1
2
3
4
5
var eggsTask = FryEggsAsync(2);     //得煎俩鸡蛋,开整!
var baconTask = FryBaconAsync(3); //得煎仨培根,开整!
var toastTask = MakeToastWithButterAndJamAsync(2); //得搞两片涂黄油和果酱的面包,开整!

var allTasks = new List<Task>{eggsTask, baconTask, toastTask}; //列个任务清单吧

可以注意到,这一段使用的几个方法,其名称都在后面加了个“Async”,这是异步方法的命名规范。调用三个异步方法,就是设置了三个任务(Task)。那谁谁,照这个任务去执行吧!我要接着跑后面的代码了。

那么,怎么定义一个异步方法呢?来看上面示例中的这个方法:

1
2
3
4
5
6
7
async Task<Toast> MakeToastWithButterAndJamAsync(int number)
{
var toast = await ToastBreadAsync(number); //要处理面包得先等面包烤好
ApplyButter(toast); //涂点黄油
ApplyJam(toast); //涂点果酱
return toast;
}

首先,方法定义的前面有async修饰符,这直接说明了此方法是异步(asynchronous)的。

异步方法返回的是Task<TResult>类型,代表着这个任务(Task)的结果是TResult所代表的类型。比如一个返回类型为Toast的同步方法,其异步版本的返回类型就应该是Task<Toast>,代表着一个“烤面包(Toast)”的任务(Task)。

async异步方法的存在,要依靠包含await运算符的表达式或语句。反过来说,异步方法里必须得有await的存在。 上面的代码里,Main方法本身也是被async修饰的,就是因为Main方法里也用到了await语句。

设置前置条件

async是用来定义异步方法的,那await是干什么的呢?按照字面意思来理解就好,“等待”。异步方法运行到这里就开始等待,直到await的操作数所表示的异步操作(一个Task<TResult>)执行完毕。一旦异步操作完成,await运算符就从Task<TResult>的任务里,获取任务的最终结果,以TResult类型返回,然后再继续运行后续代码。 这说明await所等待的任务的结果是后续操作的前置条件。上面这个异步方法第一句就在await,这是因为后面抹黄油和果酱的流程都必须建立在“烤完面包”的前置条件上。

然而,我们希望优化的耗时操作往往本身不是异步的。await只能接异步操作,怎么和非异步的耗时操作结合呢?比如说有这样一个“根正苗红”的同步函数:

1
2
3
string Foo(int bar){
Wtf();
}

要让它的执行完成作为前置条件,就得把它改造成一个返回Task<string>的函数。但是如果原函数是不允许修改的呢?依然有办法,只要用Task.Run(() => Foo(bar))来调用就好了。

Task.Run()可以把以下四种委托包装成任务,其中常用的是前两种:

  1. Action
  2. Func<TResult>
  3. Func<Task>
  4. Func<Task<TResult>>

由于Lambda表达式也是委托,完全可以构造一个符合上述种类的Lambda表达式。() => Foo(bar)没有参数,返回类型为string,是一个受到支持的Func<string>委托。因此在被Task.Run()包装之后,它就能成为一个Task<string>,作为异步过程中的前置条件。

使用连接符

再来看中间的这一段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
while (allTasks.Any())
{
Task finished = await Task.WhenAny(allTasks);
if (finished == eggsTask)
{
Console.WriteLine("eggs are ready");
}
else if (finished == baconTask)
{
Console.WriteLine("bacon is ready");
}
else if (finished == toastTask)
{
Console.WriteLine("toast is ready");
}
allTasks.Remove(finished);
}

allTasks.Any()使用List<T>Any()方法检查列表里是否还有剩余的元素,即当还有未完成的任务时,令程序一直在此循环,这实际上类似于一个消息循环机制。

Task.WhenAny(allTasks)有点儿特殊,它是一个Task<Task>,即“结果是任务”的任务——在allTasks里的某一个任务完成时,它把这个刚刚完成的任务作为自己的结果。这样,await运算符就提取出了那个刚刚完成的任务,将它赋给finished,接下来就可以作出相应的反应了。别忘了在任务处理完之后,把这个完成了的任务从任务列表里删去。

另有一个类似的方法是Task.WhenAll(),它所创建的任务在参数所表示的一系列任务都完成时才完成。命名空间System.Threading.Tasks里的这类辅助处理多个任务的方法被称为“连接符”。

以上就是一种基于任务的异步模式(TAP):把多个任务一齐启动,记录在任务列表里,然后用await、循环和连接符来等待所有任务的完成。对于每个任务本身,如果具有一些前置条件,就依然用await来等待其前置条件的完成。

扩展:线程池

至此,虽然我们知道了怎么把同步代码改造成异步的,但其中的原理是什么呢?

异步的关键是定义async异步方法和用await进行必要的流程控制,而这两个关键字都是围绕Task<TResult>展开的。因此要更深入地理解异步,就要了解Task<TResult>的工作机制。

Task工作的基础是线程池,C#中的线程池是命名空间System.Threading中的ThreadPool静态类。关于线程池和多线程又可以事无巨细地写一篇长文,这里先作简要的记录。

每一个进程都可以拥有一个线程池,里面有预先创建好的一大堆空闲线程。当一个任务需要用线程处理的时候,就无需临时单独创建一个线程,可以直接从线程池里找一个空闲的来跑。跑完也不用费劲将线程销毁,它会被线程池回收,等待其它任务来利用。假如要处理的任务太多,导致线程池里所有的线程都在忙碌,线程池可能会创建新线程,也可能让任务等待空闲线程的出现。

线程池也有缺点。由于池里线程的一切工作都是由CLR托管的(这又是一个天坑),虽然用起来是简单了,但你无法对这些线程进行具体的操作,一旦把任务加进队列里也没法取消(不要停下来啊!)。不过都要用上线程池了,那不是一把梭跑就完事了嘛,谁还希望让任务停下来呢?

使用线程池的方法是利用QueueUserWorkItem()方法:

1
2
3
4
5
//ThreadPool.QueueUserWorkItem 方法

public static bool QueueUserWorkItem (System.Threading.WaitCallback callBack);

public static bool QueueUserWorkItem (System.Threading.WaitCallback callBack, object state);

这个方法把一项工作添加到线程池的工作队列中,一旦线程池有空闲线程,就会从队列里取出工作来执行。

其中,WaitCallback是一个委托,它接收object作为参数,并返回void,类似Action<object>

1
2
[System.Runtime.InteropServices.ComVisible(true)]
public delegate void WaitCallback(object state);

注意,由于委托参数的逆变性(我靠,居然在这里用上了前面学的逆变),这里仅能使用object或派生程度更低的类型的参数。由于object已经是最终基类,故只能用它。

object可是啥都没有啊?如果要安排一个带有任务信息的委托作为任务,怎么把信息封在里面?

为了解答这个问题,我们可以先看QueueUserWorkItem的后一个重载。参数除了WaitCallback类型的委托callBack之外,还有一个object state,它就是委托调用时使用的参数。由于协变性,你可以把任何类型视作object,也就可以在调用委托时传入任意类型的参数。而前一个重载的参数列表中没有object state,是给无需在调用时传入参数的委托使用的,类似Action

如此一来就很明白了,支持添加到线程池工作队列里的工作是这样的函数:返回类型为void,参数列表中有0或1个任意类型的参数。

未竟之旅

原本这里应该有更多关于Task和await工作原理的内容,但当我在C#文档的迷宫中走得愈发深入时,我发现我的理解被不断推翻,比如说用async和await实现的异步实际上是单线程的,但它们所围绕的Task又和用线程池实现的多线程密不可分。

我试图理清这一切到底是如何工作的,这时回调函数、消息循环、线程调度、编译原理这几只怪物都跑了出来,甚至将一切都指向了JavaScript,告诉我是时候敬而远之了。

因此,目前这篇笔记是十分没有深度的一篇,它有太多可以写也需要写的内容了。C#我还有更多的东西一知半解,目前在此考据技术细节是不明智的。但过段时间我还会继续刨根究底,现在将非常具有参考价值的一篇StackOverflow问题链接贴在这里:

If async-await doesn’t create any additional threads, then how does it make applications responsive?

以及之前我画的理解错误的示意图:

BreakfastAsync.png

下一步,应该是回过头去搞清楚集合、列表、数组,还有相关的接口和索引器啥的。