.NET为什么要使用异步(async)编程？

近期对于异步和多线程编程有些启发，所以我决定把自己的理解写下来。

思考：为什么要使用异步编程？

我们先看看同步方法和异步方法之前在程序中执行的逻辑：

1. 同步方法

static void Main(string[] args)
{
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：开始");
    // 调用同步方法
    SyncTestMethod();
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：结束");
    Console.ReadKey();
}

/// <summary>
/// 同步方法
/// </summary>
static void SyncTestMethod()
{
    for (int i = 0; i < 10; i++)
    {
        var str = $"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}:SyncTestMethod{i}";
        Console.WriteLine(str);
        Thread.Sleep(10);
    }
}

控制台打印：

2019-03-26 14:44:05 445：开始
2019-03-26 14:44:05 445:SyncTestMethod0
2019-03-26 14:44:05 445:SyncTestMethod1
2019-03-26 14:44:05 445:SyncTestMethod2
2019-03-26 14:44:05 445:SyncTestMethod3
2019-03-26 14:44:05 445:SyncTestMethod4
2019-03-26 14:44:05 445:SyncTestMethod5
2019-03-26 14:44:05 445:SyncTestMethod6
2019-03-26 14:44:05 445:SyncTestMethod7
2019-03-26 14:44:05 445:SyncTestMethod8
2019-03-26 14:44:05 445:SyncTestMethod9
2019-03-26 14:44:05 445：结束

主线程在调用同步方法时，会直接在主线程中执行同步方法，这个时候若SyncTestMethod方法后面还有其它方法，都需要等待SyncTestMethod执行完成。

2. 异步方法

static void Main(string[] args)
{
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：开始");
    // 调用异步步方法
    AsyncTestMethod();
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：结束");
    Console.ReadKey();
}


/// <summary>
/// 异步方法
/// </summary>
/// <returns></returns>
static async Task AsyncTestMethod() {
   await Task.Run(() => {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine($"AsyncTestMethod");
            Thread.Sleep(10);
       }
    });
}

控制台打印：

2019-03-26 14:52:37 5237：开始
2019-03-26 14:52:37 5237：结束
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod
2019-03-26 14:52:37 5237：AsyncTestMethod

主线程在调用异步方法时，默认还是会在主线程中执行，但是如果异步方法中使用了
Task.Run(()=>{}) 这种方式执行异步任务，异步任务将会在一个独立的线程去执行异步方法，调用过AsyncTestMethod方法之后，不会阻塞主线程并直接执行AsyncTestMethod后面的主线程其它方法，这个时候主线程也不会等待异步方法执行完成。并且这个时候主线程无法知晓异步方法会在什么时候执行完成，所以此时也无法在主线程中直接获取异步方法的返回，如果需要在异步方法执行完成之后再在主线程中执行其它方法，则需要使用Wait()来等待异步任务执行完成。

3. 等待(awiat)异步方法

static void Main(string[] args)
{
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：开始");
    // 调用异步步方法
    AsyncTestMethod();
    // 等待异步方法执行完成
    m1.Wait();
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：结束");
    Console.ReadKey();
}


/// <summary>
/// 异步方法
/// </summary>
/// <returns></returns>
static async Task AsyncTestMethod() {
   await Task.Run(() => {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：AsyncTestMethod");
            Thread.Sleep(10);
       }
    });
}

控制台打印：

2019-03-26 14:55:51 5551：开始
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：AsyncTestMethod
2019-03-26 14:55:51 5551：结束

主线程在调用异步方法时，由于使用了Task.Run(()=>{}) 创建异步任务，所以异步任务会在一个独立的线程去执行，然后在调用AsyncTestMethod方法之后执行了对AsyncTestMethod方法的等待Wait()，这个时候主线程会等待异步方法执行完成，不会执行后续的方法，在AsyncTestMethod执行完成之后，等待结束，此时可以拿到异步方法AsyncTestMethod的返回值，然后再继续执行主线程中的后继方法。

4. 同步线程和异步线程关联执行

如有以下方法：

static int Method1()
{
    Thread.Sleep(200);
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我计算了一个值耗费200ms");
    return 1;
}
static int Method200ms()
{
    Thread.Sleep(200);
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我做了一件耗费200ms的事情");
    return 200;
}
static int Method500ms(int index)
{
    Thread.Sleep(500);
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我做了一件耗费500ms的事情");
    return ++index;
}
static int Method1000ms()
{
    Thread.Sleep(1000);
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我做了一件耗费1000ms的事情");
    return 1000;
}

Method500ms()需要Method1()的返回值作为参数，如果所有的方法同步执行在最后计算a、b、c、d的和：

 static void Main(string[] args)
{
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：开始");
    var a = Method1();
    var b = Method200ms();
    var c = Method500ms(a);
    var d = Method1000ms();
    var result = a+b+c+d;
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：最后得到的结果{result}");
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：结束");
    Console.ReadKey();
}

控制台打印：

2019-03-26 15:10:06 106：开始
2019-03-26 15:10:06 106：我计算了一个值耗费200ms
2019-03-26 15:10:06 106：我做了一件耗费200ms的事情
2019-03-26 15:10:07 107：我做了一件耗费500ms的事情
2019-03-26 15:10:08 108：我做了一件耗费1000ms的事情
2019-03-26 15:10:08 108：最后得到的结果1203
2019-03-26 15:10:08 108：结束

同步执行的时候，需要逐一等待所有的方法执行完成，花费的时间显然是所有的方法耗费的时间之和。

对于以上四个方法，如果使用异步的方式来执行，将会很大程度的节省程序的运行时间，修改方法如下：

static async Task<int> AsyncMethod1()
{
    await Task.Run(()=> {
        Thread.Sleep(200);
        Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我计算了一个值耗费200ms");
    });
    return 1;
}
static async Task<int> AsyncMethod200ms()
{
    await Task.Run(() => {
        Thread.Sleep(200);
        Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我做了一件耗费200ms的事情");
    });
    return 200;
}
static async Task<int> AsyncMethod500ms(int index)
{
    await Task.Run(() => {
        Thread.Sleep(500);
        Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我做了一件耗费500ms的事情");
    });
    return ++index;
}
static async Task<int> AsyncMethod1000ms()
{
    await Task.Run(() => {
        Thread.Sleep(1000);
        Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：我做了一件耗费1000ms的事情");
    });
    return 1000;
}

使用异步的方式来调用方法：

static void Main(string[] args)
{
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：开始");
    var m1 = AsyncMethod1();
    var m2 = AsyncMethod200ms();
    var m4 = AsyncMethod1000ms();
    m1.Wait();
    var m3 = AsyncMethod500ms(m1.Result);
    m2.Wait();
    m3.Wait();
    m4.Wait();
    var result = m1.Result + m2.Result + m3.Result + m4.Result;
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：最后得到的结果{result}");
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：结束");
    Console.ReadKey();
}

控制台打印：

2019-03-26 14:11:54 1154：开始
2019-03-26 14:11:54 1154：我计算了一个值耗费200ms
2019-03-26 14:11:54 1154：我做了一件耗费200ms的事情
2019-03-26 14:11:55 1155：我做了一件耗费500ms的事情
2019-03-26 14:11:55 1155：我做了一件耗费1000ms的事情
2019-03-26 14:11:55 1155：最后得到的结果1203
2019-03-26 14:11:55 1155：结束

因为 AsyncMethod500ms() 依赖于AsyncMethod1()的返回结果作为参数，所以我们可以先直接以异步的方式运行AsyncMethod1()，AsyncMethod200ms()，AsyncMethod1000ms()三个方法，这个时候三个方法都会在独立的线程中执行，但是后面的AsyncMethod500ms()想要执行，必须的有AsyncMethod1()的返回值，所以这个时候对AsyncMethod1()进行等待，200ms后，AsyncMethod1()执行完成，m1.Wait()等待结束，继续执行AsyncMethod500ms()，并传入了AsyncMethod1()的返回值m1.Result,最后因为需要对四个方法的返回值进行累加，所以在这之前必须保证其它三个方法也执行完成，所以需要分别对AsyncMethod500ms()，AsyncMethod200ms()，AsyncMethod1000ms()进行等待(Wait)，因为此刻所有的方法都是异步执行的，所以程序的执行时间将≈执行时间最长的那个方法的执行时间（AsyncMethod1000ms()执行1000ms，执行时间最长，程序的执行时间≈1000ms）。

5. 验证async Task和Task.Run是否在独立执行

static void Main(string[] args)
{
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：开始");

    Console.WriteLine($"主线程ManagedThreadId： {Thread.CurrentThread.ManagedThreadId}");
    var atm = AsyncTestMethod();
    atm.Wait();
    Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ms")}：结束");
    Console.ReadKey();
}

static async Task AsyncTestMethod()
{
    Console.WriteLine($"AsyncTestMethod当前线程ManagedThreadId：{Thread.CurrentThread.ManagedThreadId}");
    await Task.Run(() =>
    {
        Console.WriteLine($"AsyncTestMethod=>Task.Run当前线程ManagedThreadId：{Thread.CurrentThread.ManagedThreadId}");
    });
}

控制台打印：

2019-03-27 16:25:03 253：开始
主线程ManagedThreadId：1
AsyncTestMethod当前线程ManagedThreadId：1
AsyncTestMethod=>Task.Run当前线程ManagedThreadId：4
2019-03-27 16:25:03 253：结束

这里可以看到AsyncTestMethod的确是跑在主线程上的，虽然微软一再强调Task是对异步的抽象，而非线程，但是这里可能有些难以理解。而Task.Run是运行在一个独立的线程中，这样就能实现和主线程并行执行。

疑惑

既然异步Task并非线程的抽象，而只是异步的抽象，那么async Task到底解决了什么问题？

在我们的程序中，程序内部执行开销可以这样分为两部分：CPU 、I/O

而CPU和I/O的比例可能是这样：

上图中，黄色部分代表的是CPU占用、而紫色部分代表的是I/O占用，可以看到的是I/O的过程远比CPU占用要长的多，并且I/O的过程中是不占用CPU的，但是在同步方法中，可能表现如下：

• 主线程在1-2进行了大量的计算，此时占用了CPU一部分时间
• 主线程在2-3时进行了I/O处理，但是这个时候几乎不占用CPU，而只是在原地等待并且占用了主线程
• 主线程在3-4进行一系列的参数或者值的传递，占用了一小部分CPU

从上面的流程中，可以看出CPU在程序运行的过程中并不会一直被占用，而线程是在CPU上面的抽象出来的，并且线程这种资源在服务器上也是有限的，当工作进行到I/O时，线程依然被占用，虽然它并没有使用任何CPU资源，但是它就是占用着一个线程在原地等待，显然这是一种非常浪费的行为。

我们举个例子

假设服务器最大只支持100个线程，在同步方法中当第101个请求发起时，它就需要进行排队，并且需要一直等到前面的100个请求中的某一个响应返回之后才能进入程序中。

而async Task优化了这个问题，在异步方法中，由于使用了await和async，I/O绑定时会将当前的线程释放，从而让服务器能有一个可用的空闲线程去处理其它请求。如下图：

启发

await async Task 对于服务器而言，相比同步方法就是利用了I/O时的释放线程的间隙，此时服务器就能够有一个空闲线程处理其它的请求，从而提高服务器的处理能力。

看完上面的内容，可以确定的是，在某些情况下，异步编程能够很大的提高我们程序运行的效率，但是大家都在推崇的多使用异步编程不仅仅是因为软件上面的原因，在硬件上也有着一些的原因。
前段时间我们将原来跑在一台办公电脑的程序发布到一台双路E5的DELL的刀片机上面去，结果发现在DELL刀片机上面运行的性能竟然比之前的办公电脑还差，开始我们怀疑是DELL刀片机使用的是虚拟机的问题，可能在某些地方没有设置好，后来经过一系列的服务器性能测试，无论是CPU处理速度、磁盘IO还是网络带宽，DELL刀片机都远超我们之前的那台办公电脑，但是我们运行的程序中的某个接口在效率上就是不如之前的办公电脑！！！
???(直到后来的某一天，随着我对.NET Core异步编程的理解的加深，终于明白是什么原因。)

我们先来看一下我们日常开发使用的Intel CPU和服务器使用的CPU对比

开发电脑CPU：英特尔® 酷睿™ i5+8500 处理器

• 处理器基本频率：3GHz
• 最大睿频频率：4.1GHz
• 内核数：六核心
• 线程数：六线程

服务器CPU：英特尔® 至强® D-2177NT 处理器

• 处理器基本频率：1.90 GHz
• 最大睿频频率：3.00 GHz
• 内核数：14
• 线程数：28

从上面的对比我们可以发现两者之间的差异很明显，i5处理器的基本频率和最大睿频都高于服务器使用的至强处理器，但是在内核数量和线程数量上面却远远不如至强,如果我们的程序全部使用的同步编程的话，以WebApi为例，每一次请求中调用的方法都只是在CPU的某一个内核/线程中进行的，换句话说，CPU单核频率的高低直接影响着同步方法的执行效率，而我们之前的程序几乎都是使用了同步方法，在办公电脑上的i5处理器和服务器使用的至强处理器的单核频率的差异显然就是之前性能问题的直接原因。

并且鉴于服务器CPU的特性（单核频率低，内核/线程数多），在程序中多使用异步/多线程的方式对于程序的性能而言是无容置疑的。

注意：

虽然异步编程很多时候能提升程序的效率，但不并意味着需要为了使用异步而将所有的方法改为异步执行，如果同步执行的开销甚至比创建一个异步线程开销还低的时候，就完全没有必要再此处使用异步的方式。至于这其中的权衡利弊，或许需要大量的测试才能得出最佳实践。

以上就是我目前对异步/多线程编程方式的理解，若有不对的地方，望请指出。