异步原理
同步 vs 异步
同步操作会在返回调用者之前完成它的工作
异步操作会在返回调用者之后去做它的（大部分）工作
- 异步的方法更为少见，会启用并发，因为它的工作会与调用者并行执行
- 异步方法通常很快（立即）就会返回到调用者，所以叫非阻塞方法
目前见到的大部分的异步方法都是通用目的的：
- Thread.Start
- Task.Run
- 可以将 continuation 附加到 Task 的方法
- …
什么是异步编程
-
异步编程的原则是将长时间运行的函数写成异步的。
-
传统的做法是将长时间运行的函数写成同步的，然后从新的线程或 Task 进行调用，从而按需引入并发。
上述异步方式的不同之处在于，它是从长时间运行函数内部启动并发。这有两点好处;
- I/O-bound 并发可不使用线程来实现。可提高扩展性和执行效率。
- 富客户端在 worker 线程会使用更少的代码，简化了线程安全性。
异步编程的两种用途
- 编写高效处理大量并发 I/O 的应用程序（典型的：服务器端应用）
- 挑战并不是线程安全（因为共享状态通常是最小化的），而是执行效率。
- 特别的，web应用程序中，每个网络请求并不会消耗一个线程
- 在富客户端应用程序里简化线程安全
- 如果调用图中任何一个操作是长时间运行的，那么整个调用图（call graph）必须运行在 worker 线程上，以保证 UI（主线程）响应。
- 得到一个横跨多个方法的单一并发操作（粗粒度）；
- 需要为调用图（call graph）中每个方法考虑线程安全
- 异步的调用图（call graph），直到需要才开启一个线程，通过较浅，即该线程在调用图中只有一两层的深度（I/O-bound 操作完全不需要，可以使用回调的方式）
- 其它方法可以在 UI 线程执行，线程安全简化
- 并发的粒度适中：
- 一连串的小的并发操作，操作之间会弹回到 UI 线程
- 如果调用图中任何一个操作是长时间运行的，那么整个调用图（call graph）必须运行在 worker 线程上，以保证 UI（主线程）响应。
调用图（call graph）如下示例
一点建议
为了获得上述的异步的好处，下列操作建议异步编写;
- I/O-bound 和 Compute-bound 操作
- 执行超过 50 毫秒的操作
另一方面过细的粒度会损害性能，因为异步操作也有开销。
异步编程和Continuation
-
Task 非常适合异步编程，因为它们支持 Continuation（它对异步非常重要）。
- 前文中有提到的TaskCompletionSource 的例子就支持Continuation。
- TaskCompletionSource 是实现底层 IO-bound 异步方法的一种标准方式。
-
对于 Compute-bound 方法，Task.Run 会初始化绑定线程的并发
- 具体实现就是把 task 对象返回给调用者，然后创建异步方法；
- 目标是在调用图较低的位置来这样做
- 这样的化，在富客户端应用中，高级方法可以保留在 UI 线程和访问控制以及共享状态上，不会出现线程安全的问题。
下面通过一个例子的代码逐步改变，演示上
-
传统同步的代码写法。输出的结果数字按顺序显式，耗时较长。
class Program { static void Main(string[] args) { DisplayPrimeCounts(); } static void DisplayPrimeCounts() //假设这是UI线程 { for (int i = 0; i < 10; i++) { Console.WriteLine(GetPrimesCount(i * 1000000 + 2, 1000000) + " primes between " + (i * 1000000) + " and " + ((i + 1) * 1000000 - 1)); } Console.WriteLine("Done!"); } static int GetPrimesCount(int start, int count) //这是个耗时操作 { return ParallelEnumerable.Range(start, count).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n)-1).All(i => n % i > 0)); } } -
更改为“粗“粒度的异步方式。
class Program { static void Main(string[] args) { //DisplayPrimeCounts(); //“粗“粒度方式，将整个调用图都运行在 Task.Run 中了，效果不好 Task.Run(() => DisplayPrimeCounts()); } static void DisplayPrimeCounts() //假设这是UI线程 { for (int i = 0; i < 10; i++) { Console.WriteLine(GetPrimesCount(i * 1000000 + 2, 1000000) + " primes between " + (i * 1000000) + " and " + ((i + 1) * 1000000 - 1)); } Console.WriteLine("Done!"); } static int GetPrimesCount(int start, int count) //这是个耗时操作 { return ParallelEnumerable.Range(start, count).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n)-1).All(i => n % i > 0)); } } -
更改为“中”粒度的异步方式，将 GetPrimesCount 方法改为异步方法。输出结果是乱序的。
class Program { static void Main(string[] args) { DisplayPrimeCounts(); Console.ReadKey(); } static void DisplayPrimeCounts() //假设这是UI线程 { for (int i = 0; i < 10; i++) { var awaiter = GetPrimesCountAsync(i * 1000000 + 2, 1000000).GetAwaiter(); awaiter.OnCompleted(() => Console.WriteLine(awaiter.GetResult() + " primes between ...")); } Console.WriteLine("Done!"); } static Task<int> GetPrimesCountAsync(int start, int count) { return Task.Run(() => ParallelEnumerable.Range(start, count).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0))); } } -
需要对 task 的执行结果序列化，比如让 Task b 依赖于 Task a 的执行结果。以 3 中的代码为例，必须在 continuation 内部触发下一次循环。
class Program { static void Main(string[] args) { DisplayPrimeCounts(); Console.ReadKey(); } static void DisplayPrimeCounts() //假设这是UI线程 { DisplayPrimeCountsForm(0); } static void DisplayPrimeCountsForm(int i) { var awaiter = GetPrimesCountAsync(i * 1000000 + 2, 1000000).GetAwaiter(); awaiter.OnCompleted(() => { Console.WriteLine(awaiter.GetResult() + " primes between ..."); if (++i < 10) { DisplayPrimeCountsForm(i); //在 continuation 内部触发下一次循环 } else { Console.WriteLine("Done"); } }); } static Task<int> GetPrimesCountAsync(int start, int count) { return Task.Run(() => ParallelEnumerable.Range(start, count).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0))); } } -
在 4 中DisplayPrimeCounts方法仍然不是异步的，需要将其更改为异步方法。
class Program { static void Main(string[] args) { DisplayPrimeCounts(); Console.ReadKey(); } public static Task DisplayPrimeCounts() //假设这是UI线程 { var machine = new PrimesStateMachine(); machine.DisplayPrimeCountsForm(0); return machine.task; } public static Task<int> GetPrimesCountAsync(int start, int count) { return Task.Run(() => ParallelEnumerable.Range(start, count).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0))); } } class PrimesStateMachine { TaskCompletionSource<object> _tcs = new TaskCompletionSource<object>(); public Task task { get { return _tcs.Task; } } public void DisplayPrimeCountsForm(int i) { var awaiter = Program.GetPrimesCountAsync(i * 1000000 + 2, 1000000).GetAwaiter(); awaiter.OnCompleted(() => { Console.WriteLine(awaiter.GetResult() + " primes between ..."); if (++i < 10) { DisplayPrimeCountsForm(i); //在 continuation 内部触发下一次循环 } else { Console.WriteLine("Done"); } }); } } -
在 5 中虽然实现了想要的结果，但是实现起来比较繁琐，且代码量大。这时就可以使用 C# 中的 async 和 await 关键字来优化。
class Program { static async Task Main(string[] args) { await DisplayPrimeCountsAsync(); } async static Task DisplayPrimeCountsAsync() { for (int i = 0; i < 10; i++) { Console.WriteLine(await GetPrimesCountAsync(i * 1000000 + 2, 1000000) + " primes between " + (i * 1000000) + " and " + ((i + 1) * 1000000 - 1)); } Console.WriteLine("Done!"); } static Task<int> GetPrimesCountAsync(int start, int count) { return Task.Run(() => ParallelEnumerable.Range(start, count).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0))); } }由上述例子可知：
- 使用 async 和 await 大大减少了代码量，对于不想复杂地实现异步非常重要。
- 命令式循环结构不要和 continuation 混合在一起，因为它们依赖于当前本地状态。
-
对于 6 中的例子，还有另外一种实现：函数式写法（Linq 查询），它也是 响应式编程（Rx）的基础。这种方法会更加有难度。
3689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
