c#异步编程-Task（二）

一、概要

大家好，本次继续分享自己的学习经历。本文主要分享Task异步编程内容，如果能帮助大家希望多多关注文章末尾的微信公众号和知乎三连。各位举手之劳是对我更新技术文章最大的支持。

二、详细内容

1.同步异步

• 同步操作会在返回调用者之前完成它的工作
• 异步操作会在返回调用者之后去做它的工作
• 异步的方法更为少见，会启用并发，因为他的工作会与调用者并行执行
• 目前见到的大部分的异步方法都是通用目的的：
• Thread.Start
• Task.Run
• 可以将continuation附加到Task的方法

什么是异步编程

• 异步编程的原则是将长时间运行的函数写成异步的。
• 传统做法是将长时间运行的函数写成同步的，然后从新的线程或Task进行调用从而按需引入并发。
• 上述异步方式的不同之处在于，它是长时间运行函数的内部启动并发。有这两点好处
• IO-bound并发可不适用线程来实现。可提供可扩展性和执行效率；
• 富客户端在worker线程会使用更少的代码，简化了线程安全性。

异步编程的两种用途

调用图（call graph）

• 编写高效处理大量并发IO的应用程序（典型的：服务器端应用）
• 挑战并不是线程安全（因为共享状态通常是最小化的），而是执行效率
• 特别的，每个网络请求并不会消耗一个线程。
• 调用图
• 在富客户端应用里简化线程安全。
• 如果调用图中任何一个操作时长时间运行的，那么整个call graph必须运行在worker线程上，以保证UI响应。
• 得到一个横跨多个方法的单一并发操作；
• 需要为call graph中的每个方法考虑线程安全。
• 异步的call graph，只要需要才开启一个线程，通常较浅（IO-bound操作完全不需要）
• 其他的方法可以在UI线程执行，线程安全简化。
• 并发的粒度适中： -一连串小的并发操作，操作之间会弹回到UI线程

经验之谈

为了获得上述好处，下列操作建议异步编写：

• IO-bound和compute-bound操作
• 执行超过50毫秒的操作
• 另一方面过细的粒度会损害性能，因为异步操作也有开销。

注：

• IO-bound（I/O密集型）表示： 指的是系统的CPU效能相对硬盘/内存的效能要好很多，此时，系统运作，大部分的状况是 CPU 在等 I/O (硬盘/内存) 的读/写，此时 CPU Loading 不高。
• Compute-bound（计算密集型）表示： 指的是系统的 硬盘/内存 效能 相对 CPU 的效能 要好很多，此时，系统运作，大部分的状况是 CPU Loading 100%，CPU 要读/写 I/O (硬盘/内存)，I/O在很短的时间就可以完成，而 CPU 还有许多运算要处理，CPU Loading 很高。在多重程序系统中，大部分时间用来做计算、逻辑判断等CPU动作的程序。例如一个计算圆周率至小数点一千位以下的程序，在执行的过程当中绝大部份时间用在三角函数和开根号的计算，便是属于CPU bound的程序。

2.异步和Coninuation以及语言的支持

• Task非常适合异步编程，因为他们支持Continuation（它对异步非常重要）
• TaskCompletionSource是实现底层IO-bound异步方法的一种标准方式
• 对于Compute-bound方法，Task.Run会初始化绑定线程的并发。
• 把task返回调用者，创建异步方法；
• 异步编程的区别：目标是在调用图较低的位置来这样做。
• 富客户端应用中，高级方法可以保留在UI线程和访问控制以及共享状态上，不会出现线程安全问题

代码例子：

//例子1，同步方法进行Compute-bound操作
    static void Main(string[] args)
    {
        DisplayCounts();
        //粗粒度异步调用
        //Task.Run(()=>{ DisplayCounts(); });
        Console.ReadKey();
    }

    static void DisplayCounts() 
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine(GetPrimesCount(i*1000000 + 2,1000000) + "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));
    }

//例子2，异步方法执行Compute-bound操作
    static void Main(string[] args)
    {
        //细粒度异步调用
        DisplayCounts();
        Console.ReadKey();
    }

    static void DisplayCounts() 
    {
        for (int i = 0; i < 10; i++)
        {
            var awaiter = GetPrimesCount(i * 1000000 + 2, 1000000).GetAwaiter();
            awaiter.OnCompleted(()=> 
            Console.WriteLine(awaiter.GetResult())
            );
        }
        Console.WriteLine("Done!");
    }

    static Task GetPrimesCount(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)));
    }

在例子1中同步执行是有序输出，例子2中的执行输出顺序是乱的且Done是最先输出出来的，这个结果并不是我们想要的接下来需要进行一些优化。

语言对异步的支持非常重要

• 需要对task的执行序列化
• 例如Task B依赖于 Task A的执行结果。
• （例子）为此，必须在continuation内部触发下一次循环

代码示例：

//例子3，有序异步执行
    static void Main(string[] args)
    {
        //这里的调用非完全异步
        DisplayCounts();
        Console.ReadKey();
    }

    static void DisplayCounts()
    {
        DisplayCountsFrom(0);
    }

    static void DisplayCountsFrom(int i) 
    {
        var awaiter = GetPrimesCount(i * 1000000 + 2, 1000000).GetAwaiter();
        awaiter.OnCompleted(() => 
        { 
            Console.WriteLine(awaiter.GetResult());
            if (++i < 10)
            {
                DisplayCountsFrom(i);
            }
            else
                Console.WriteLine("Done!");
        });
    }

    static Task GetPrimesCount(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，完全异步执行
    static void Main(string[] args)
    {
        DisplayPrimeCountsAsync();
        Console.ReadKey();
    }

    public static Task DisplayPrimeCountsAsync() 
    {
        var machine = new PrimesStateMachine();
        machine.DisplayCountsFrom(0);
        return machine.Task;
    }

    public static void DisplayCountsFrom(int i) 
    {
        var awaiter = GetPrimesCount(i * 1000000 + 2, 1000000).GetAwaiter();
        awaiter.OnCompleted(() => 
        { 
            Console.WriteLine(awaiter.GetResult());
            if (++i < 10)
            {
                DisplayCountsFrom(i);
            }
            else
                Console.WriteLine("Done!");
        });
    }

    public static Task GetPrimesCount(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