在.NET Core中使用异步编程的方法步骤

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

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

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

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 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod
2019-03-26 14:52:37 5237AsyncTestMethod

主线程在调用异步方法时，将会新建一个子线程去执行异步方法，调用过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 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551AsyncTestMethod
2019-03-26 14:55:51 5551结束

主线程在调用异步方法时，将会新建一个子线程去执行异步方法，并且在调用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 ）。

看完上面的内容，可以确定的是，在某些情况下，异步编程能够很大的提高我们程序运行的效率，大家都在推崇的多使用异步编程不仅仅是因为软件上面的原因，在硬件上也有着很大的原因。

前段时间我们将原来跑在一台办公电脑的程序发布到一台双路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的特性（单核频率低，内核/线程数多），在程序中多使用异步/多线程的方式对于程序的性能而言是无容置疑的。

注意

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

以上就是我目前对.NET Core中使用异步/多线程编程方式的理解， 希望对大家的学习有所帮助，也希望大家多多支持狼蚁SEO。