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

dotnet---1.jpg

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

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

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

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执行完成。


sync

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()来等待异步任务执行完成。

async

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的返回值，然后再继续执行主线程中的后继方法。

awitasync

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：结束

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


sync2

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

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）。

awitasync2

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的比例可能是这样：


----_20190327164302

上图中，黄色部分代表的是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绑定时会将当前的线程释放，从而让服务器能有一个可用的空闲线程去处理其它请求。如下图：

---------1

启发

**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的特性（单核频率低，内核/线程数多），在程序中多使用异步/多线程的方式对于程序的性能而言是无容置疑的。

注意：

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

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

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,839评论 6赞 482
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,543评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 153,116评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,371评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,384评论 5赞 374
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,111评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,416评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,053评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,558评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,007评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,117评论 1赞 334
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,756评论 4赞 324
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,324评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,315评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,539评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,578评论 2赞 355
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,877评论 2赞 345

推荐阅读更多精彩内容

  • iOS多线程编程
    iOS多线程编程 基本知识 1. 进程（process) 进程是指在系统中正在运行的一个应用程序，就是一段程序的执...
    陵无山阅读 6,005评论 1赞 14
  • 面试题
    Swift1> Swift和OC的区别1.1> Swift没有地址/指针的概念1.2> 泛型1.3> 类型严谨 对...
    cosWriter阅读 11,089评论 1赞 32
  • 进程,线程 ->iOS 多线程 runloop
    又来到了一个老生常谈的问题，应用层软件开发的程序员要不要了解和深入学习操作系统呢？ 今天就这个问题开始，来谈谈操...
    tangsl阅读 4,088评论 0赞 23
  • 进程和线程的区别（转）
    文／tangsl（简书作者） 原文链接：http://www.jianshu.com/p/2b993a4b913e...
    西葫芦炒胖子阅读 3,744评论 0赞 5
  • 读《皮囊》的感悟
    作者用一种冷静、细致、客观的笔触，将"太过在乎，太过珍贵，而被自己刻在骨头里的故事，最终通过文字，一点点重新被扒出...
    Mark_Ming阅读 907评论 0赞 3