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

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

2020-11-27 22:34:38 责编:小采

主线程在调用同步方法时，会直接在主线程中执行同步方法，这个时候若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

主线程在调用异步方法时，将会新建一个子线程去执行异步方法，调用过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：结束

主线程在调用异步方法时，将会新建一个子线程去执行异步方法，并且在调用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的特性（单核频率低，内核/线程数多），在程序中多使用异步/多线程的方式对于程序的性能而言是无容置疑的。

注意：

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

下载本文

显示全文

全部频道