关于async和await的探讨

最新推荐文章于 2022-01-14 23:01:01 发布
最新推荐文章于 2022-01-14 23:01:01 发布
阅读量187 收藏
点赞数
文章标签： 多线程 java 编程语言 c++ 并发编程
原文链接：https://mp.weixin.qq.com/s?__biz=MzAwNTMxMzg1MA==&mid=2654087051&idx=2&sn=2eb54ac6bde355cbc7a2e222bf07f002&chksm=80d803deb7af8ac8fc81fae4d1a7777ed2010e149c5cf8759d29707e1cb06b684ed0138c313c&scene=126&&sessionid=0
版权

缘起

最近在看《深入解析C#（第4版）》这本书，看到了第五章，这一章节是关于异步。之前对异步这个概念只能算是一知半解，了解了它的概念和用法，但是对它的实际场景和为了解决什么问题而诞生的是不太清楚的。于是乎，就和小伙伴之间有了一场讨论。

概念

一般来说对方法的调用都是同步执行的。例如在线程执行体内，即线程的调用函数中，方法的调用就是同步执行的。如果方法需要很长的时间来完成，比方说从Internet加载数据的方法，调用者线程将被阻塞直到方法调用完成。这时候为了避免调用者线程被阻塞，这时候就需要用到异步编程了。异步编程可以解决线程因为等待独占式任务而导致的阻塞问题。

探索

探索过程中，参考了《微软官方文档》，《I/O Threads Explained》。

例子说明

官方以一个做早餐的例子来解释了什么叫同步，并行和异步。

假设做一个早餐需要完成7个步骤：

  1. 倒一杯咖啡。

  2. 加热平底锅，然后煎两个鸡蛋。

  3. 煎三片培根。

  4. 烤两片面包。

  5. 在烤面包上加黄油和果酱。

  6. 倒一杯橙汁。

同步执行

同步执行，是指只有完成上一个任务，才会开始下一个任务；同时将阻塞当前线程执行其他操作，直至任务全部完成

代码例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
// 鉴于我用的是vs2022,可能控制台程序的代码在旧版本的vs上无法直接运行，需要补充对应的main函数
MakeBreakfast();

static void MakeBreakfast()
{
    var cup = PourCoffee();
    Console.WriteLine("coffee is ready");

    var eggs = FryEggs(2);
    Console.WriteLine("eggs are ready");

    var bacon = FryBacon(3);
    Console.WriteLine("bacon is ready");

    var toast = ToastBread(2);
    ApplyButter(toast);
    ApplyJam(toast);
    Console.WriteLine("toast is ready");

    var oj = PourOJ();
    Console.WriteLine("oj is ready");
    Console.WriteLine("Breakfast is ready!");
}

static Juice PourOJ()
{
    Console.WriteLine("Pouring orange juice");
    return new Juice();
}

static void ApplyJam(Toast toast) => 
    Console.WriteLine("Putting jam on the toast");

static void ApplyButter(Toast toast) =>
    Console.WriteLine("Putting butter on the toast");

static Toast ToastBread(int slices)
{
    for (int slice = 0; slice < slices; slice++)
    {
        Console.WriteLine("Putting a slice of bread in the toaster");
    }
    Console.WriteLine("Start toasting...");
    Task.Delay(3000).Wait();
    Console.WriteLine("Remove toast from toaster");
    return new Toast();
}

static Bacon FryBacon(int slices)
{
    Console.WriteLine($"putting {slices} slices of bacon in the pan");
    Console.WriteLine("cooking first side of bacon...");
    Task.Delay(3000).Wait();
    for (int slice = 0; slice < slices; slice++)
    {
        Console.WriteLine("flipping a slice of bacon");
    }
    Console.WriteLine("cooking the second side of bacon...");
    Task.Delay(3000).Wait();
    Console.WriteLine("Put bacon on plate");
    return new Bacon();
}

static Egg FryEggs(int howMany)
{
    Console.WriteLine("Warming the egg pan...");
    Task.Delay(3000).Wait();
    Console.WriteLine($"cracking {howMany} eggs");
    Console.WriteLine("cooking the eggs ...");
    Task.Delay(3000).Wait();
    Console.WriteLine("Put eggs on plate");
    return new Egg();
}

static Coffee PourCoffee()
{
    Console.WriteLine("Pouring coffee");
    return new Coffee();
}

public class Juice { }

public class Bacon { }

public class Egg { }

public class Coffee { }

public class Toast { }

949d65a1323ad42bb042886a144780f3.png

同步执行的总耗时是每个任务耗时的总和。此外，因为是同步执行的原因，在开始制作一份早餐的时候，如果此时又有一份制作早餐的请求过来，是不会开始制作的。如果是客户端程序，使用同步执行耗时时间长的操作，会导致UI线程被阻塞，导致UI线程无法响应用户操作，直至操作完成后，UI线程才相应用户的操作。

异步执行

异步执行，是指在遇到await的时候，才需要等待异步操作完成，然后往下执行；但是不会阻塞当前线程执行其他操作。

代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
await MakeBreakfastAsync();

static async Task MakeBreakfastAsync()
{
    var cup = PourCoffee();
    Console.WriteLine("coffee is ready");

    var eggs = await FryEggsAsync(2);
    Console.WriteLine("eggs are ready");

    var bacon = await FryBaconAsync(3);
    Console.WriteLine("bacon is ready");

    var toast = await ToastBreadAsync(2);
    ApplyButter(toast);
    ApplyJam(toast);
    Console.WriteLine("toast is ready");

    var oj = PourOJ();
    Console.WriteLine("oj is ready");
    Console.WriteLine("Breakfast is ready!");
}

static async Task<Toast> ToastBreadAsync(int slices)
{
    for (int slice = 0; slice < slices; slice++)
    {
        Console.WriteLine("Putting a slice of bread in the toaster");
    }
    Console.WriteLine("Start toasting...");
    Task.Delay(3000).Wait();
    Console.WriteLine("Remove toast from toaster");
    return await Task.FromResult(new Toast());
}

static Task<Bacon> FryBaconAsync(int slices)
{
    Console.WriteLine($"putting {slices} slices of bacon in the pan");
    Console.WriteLine("cooking first side of bacon...");
    Task.Delay(3000).Wait();
    for (int slice = 0; slice < slices; slice++)
    {
        Console.WriteLine("flipping a slice of bacon");
    }
    Console.WriteLine("cooking the second side of bacon...");
    Task.Delay(3000).Wait();
    Console.WriteLine("Put bacon on plate");
    return Task.FromResult(new Bacon());
}

static Task<Egg> FryEggsAsync(int howMany)
{
    Console.WriteLine("Warming the egg pan...");
    Task.Delay(3000).Wait();
    Console.WriteLine($"cracking {howMany} eggs");
    Console.WriteLine("cooking the eggs ...");
    Task.Delay(3000).Wait();
    Console.WriteLine("Put eggs on plate");
    return Task.FromResult(new Egg());
}

6d469afb67c400ca5a6aa9ba6a3ff39b.png

上面代码只是为了避免堵塞当前的线程，并没有真正用上异步执行的某些关键功能，所以在耗时上是相差不远的；但是这时候如果在接受了一份制作早餐的请求，还未完成的时候，又有一份制作早餐的请求过来，是可能会开始制作另一份早餐的。

改善后的异步执行

代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
await MakeBreakfastBetterAsync();

static async Task MakeBreakfastBetterAsync()
{
    Coffee cup = PourCoffee();
    Console.WriteLine("Coffee is ready");

    Task<Egg> eggsTask = FryEggsAsync(2);
    Task<Bacon> baconTask = FryBaconAsync(3);
    Task<Toast> toastTask = ToastBreadAsync(2);

    Toast toast = await toastTask;
    ApplyButter(toast);
    ApplyJam(toast);
    Console.WriteLine("Toast is ready");
    Juice oj = PourOJ();
    Console.WriteLine("Oj is ready");

    Egg eggs = await eggsTask;
    Console.WriteLine("Eggs are ready");
    Bacon bacon = await baconTask;
    Console.WriteLine("Bacon is ready");

    Console.WriteLine("Breakfast is ready!");
}

异步方法的逻辑没有改变，只是调整了一下代码的执行顺序，一开始就调用了三个异步方法，只是在await语句后置了，而不是上面那段代码一样，执行了就在那里等待任务完成，而是会去进行其他的后续操作，直至后续操作需要用到前面任务执行结果的时候，才去获取对应的执行结果，如果没有执行完成就等待执行完成才继续后续的操作。

异步执行并不总是需要另一个线程来执行新任务。并行编程是异步执行的一个子集。

并行编程

并行编程，调用多个线程，同时去执行任务

例如：需要制作五份早餐，同步和异步的方法都是需要循环调用相应的MakeBreakfast方法和MakeBreakfastBetterAsync方法五次才能制作完成。而并行编程，也就是多线程，可以一次性创建五个线程，分别制作一份早餐，从而大大缩短了所需要的时间。

代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
DateTime beforeDT = DateTime.Now;
for (int i = 0; i < 5; i++)
{
    MakeBreakfast();
}
DateTime afterDT = DateTime.Now;
TimeSpan ts = afterDT.Subtract(beforeDT);
Console.WriteLine($"同步执行程序耗时: {ts.TotalMilliseconds}ms");

beforeDT = DateTime.Now;
for (int i = 0; i < 5; i++)
{
    await MakeBreakfastBetterAsync();
}
afterDT = DateTime.Now;
ts = afterDT.Subtract(beforeDT);
Console.WriteLine($"异步执行程序耗时: {ts.TotalMilliseconds}ms");

beforeDT = DateTime.Now;
await MakeBreakfastBetterMultiTask();
afterDT = DateTime.Now;
ts = afterDT.Subtract(beforeDT);
Console.WriteLine($"并行编程程序耗时: {ts.TotalMilliseconds}ms");

static async Task MakeBreakfastBetterMultiTask()
{
    Task[] tasks = new Task[5];
    for (int i = 0; i < 5; i++)
    {
        tasks[i] = new Task((parameter) => MakeBreakfastBetterAsync().Wait(), "aaa");
        tasks[i].Start();
    }
    Task.WaitAll(tasks);
}

运行耗时结果如下

d6eae350160f8aeb7751e7116e1a4354.png

37f8f64b737948121dac4fbaaa0b0406.png

7c0b61696aba3541b6324b129f7e71b3.png

相比之下，显然能看出来之间的运行耗时差别还是有点大的。

一个通俗的例子

程序就像一个餐馆，线程就像餐馆里面已有的厨师，CPU就是调度厨师的厨师长，假设餐馆开业了，厨师长只带了5个厨师，餐馆接到的订单有8份，同步执行就是5个厨师分别处理5个订单后，这期间，他们会专心的去完成订单的菜，而无视其他的事情，直到完成订单，厨师长才会分配新的订单给他们；异步执行则是5个厨师在处理5个订单的期间，如果厨师长发现他们有人处于空闲状态，就会安排他们去执行剩下3个订单，如果收到等待中的订单可以继续操作时，厨师长会抽调厨师继续完成订单，从而增加了餐馆处理订单的能力。而并行编程则是餐馆开业的时候，告诉了厨师长，需要8个厨师；厨师长就带来了相应数量的厨师来处理订单。

这就是这两天，我对同步，异步和并行之间的感悟。如有不对，敬请指正！

推荐阅读：

《Kubernetes全栈架构师（Kubeadm高可用安装k8s集群）--学习笔记》

《.NET 云原生架构师训练营（模块一 架构师与云原生）--学习笔记》

《.NET Core开发实战（第1课：课程介绍）--学习笔记》

dotNET跨平台
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
.Net异步编程（async await）初探
11-07
针对.net异步编程（async await）使用入门的一些讲解
关于async、await浅理解
派大星儿的博客
05-07 219
async、await理解 Async 和 await 是一种同步的写法，执行异步的操作 asayc的用法，它作为一个关键字放到函数前面，这样普通函数就变为了异步函数 异步async函数调用，跟普通函数的使用方式一样 异步async函数返回一个promise对象 async函数配合await关键字使用(阻塞代码往下执行)是异步方法，但是阻塞式的 优点： 同步代码编写方式： Promise使用then函数进行链式调用，async/await从上到下，顺序执行，就像写同步代码一样，更符合代码编.
关于async和await的理解！
weixin_44269229的博客
08-15 241
使用async和await进行异步编程提高编译效率 看很多朋友还是使用的Thread来使用异步多线程操作，基本上看不见有使用Async、Await进行异步编程的。各有所爱吧，其实都可以。只要正确使用就行，不过还是写了这篇文章推荐大家使用Async、Await。 原因就是：可以跟写同步方法一样去异步编程。代码则就非常的清晰，就跟写普通的代码一样，不用关系如何去异步编程，也让很多初级程序员也能够异步编...
简单说说async/await
dotNET跨平台
06-24 413
小明用async/await写了几年的异步方法，但总没有完全理解里面的机制，他决定去请教邻居小花。小花听了小明的描述后说：首先你要明白异步的根本是什么？大白话解释异步就是：拉一个人（线程...
深入async/await知多少
dotNET跨平台
06-19 365
.net的async/await功能相信对很多人来说并不陌生了，有人感觉这功能很好，但也有人说这功能不好容易产生一些莫名其妙的死锁；有人说这些异步功能也有人说这是同步功能。其...
浅谈C#中的Async和Await的用法详解
12-31
在本文中，我们将共同探讨并介绍什么是Async 和 Await，以及如何在C#中使用Async 和 Await。 同样本文的内容也大多是翻译的，只不过加上了自己的理解进行了相关知识点的补充，如果你认为自己的英文水平还不错，大可...
async和await使用简单实例
08-30
在C#编程中，`async`和`await`是用于异步编程的关键字，它们极大地简化了编写非阻塞代码的过程。异步编程是解决I/O密集型操作（如网络请求、读写文件等）时避免阻塞主线程的重要方法。下面我们将详细探讨这两个...
ASP.NET 谨用 async/await
10-18
【ASP.NET 中慎用 async/await】\n\n在 ASP.NET 开发中，async/await 关键字的引入，使得异步编程变得更加简洁。然而，实际应用中，如果不小心，可能会遇到一系列问题，如异常捕获困难、死锁以及应用程序崩溃。本文...
async/await异步处理demo
06-27
下面我们将深入探讨`async/await`的原理、用法以及如何在实际项目中应用。 `async`关键字用于声明一个函数为异步函数，这意味着该函数会返回一个Promise。当异步函数被调用时，它并不会立即执行函数体内的代码，...
深入理解ES7的async/await的用法
08-29
本文将深入探讨async/await的用法，并与Promise和co模块进行比较。 1. async/await是什么？ async/await可以说是co模块和生成器函数的语法糖，它使用更加清晰的语义解决JavaScript异步代码。async/await返回的是...
Async---Await原理
jinglianglove的博客
12-25 592
Async—Await原理 async、await 优缺点: async 和 await 相比直接使用 Promise 来说，优势在于处理 then 的调用链，能够更清晰准确的写出代码。 缺点在于滥用 await 可能会导致性能问题， 因为 await 会阻塞代码，也许之后的异步代码并不依赖于前者，但仍然需要等待前者完成，导致代码失去了并发性。 链接：https://juejin.im/post...
[C#] C#深入浅出4th Edition [1]
unity尧明的博客
01-14 430
语境下的C#   当我在大学学习计算机科学时，一位同学纠正了讲师关于他写在黑板上的一个细节。 讲师看起来有点生气，回答说：“是的，我知道。 我在简化。 我在这里掩盖真相是为了展示更大的真相。” 虽然我希望我不会在第 1 部分中掩盖太多，但这绝对是关于更大的真相。   本书的大部分内容都是近距离观察 C#，偶尔将其置于微观范围内以查看最精细的细节。 在我们开始之前，第 1 章会回顾一下 C# 的历史，以及 C# 如何融入更广泛的计算环境。   在我提供本书其余部分的主菜之前，你会看到一些代码作为开胃菜，但在这
[C#] C#深入浅出4th Edition [2]
unity尧明的博客
01-14 948
1.1.5 平衡效率和复杂性   我记得我第一次使用 Java 的经历； 它被完全解释并且非常缓慢。 一段时间后，可选的即时 (JIT) 编译器变得可用，最终几乎理所当然地认为任何 Java 实现都是 JIT 编译的。   使 Java 表现良好需要付出很多努力。 如果语言失败了，这种努力就不会发生。 但开发人员看到了潜力，并且已经感觉比以前更有效率。 开发和交付速度通常比应用程序速度更重要。   C# 的情况略有不同。 公共语言运行时 (CLR) 从一开始就非常高效。 对与本机代码的轻松互操作以及对性能敏
C# async 和 await
weixin_30258027的博客
12-19 301
.NET 中的 async/await 异步编程 2015/04/08 ·IT技术·.Net,异步编程 分享到：3 python正则表达式 React入门 走进大数据之storm流式计算基础 Shell典型应用之系统信息及运行状态获取 原文出处：Teroy 的博客欢迎分享原创到伯乐头条 前言 最近在学习Web Api框...
.net中async/await异步编程
致我的奋斗
04-03 1万+
C#5.0中引入了构建异步方法的新特性---async/await。本文根据自己的理解讲述异步方法三种返回方式和取消异步操作的示例。在此之前先说说异步方法的语法特点：方法名称一般是Async 结尾。可以包含一个或者多个await表达式。异步方法的参数不能使用ref和out参数。方法头包含async关键字，并且在返回类型之前。除了方法之外， Lambda 表达式和匿名函数也可以作为异步对象。先来看看...
async/await 的基本实现和 .NET Core 2.1 中相关性能提升
diaoyin8902的博客
05-07 427
前言 这篇文章的开头，笔者想多说两句，不过也是为了以后再也不多嘴这样的话。 在日常工作中，笔者接触得最多的开发工作仍然是在 .NET Core 平台上，当然因为团队领导的开放性和团队风格的多样性（这和 CTO 以及主管的个人能力也是分不开的），业界前沿的技术概念也都能在上手的项目中出现。所以虽然现在团队仍然处于疾速的发展中，也存在一些奇奇怪怪的事情，工作内容也算有紧有松，但是总体来说也算...
如何在.net4.0中使用.net4.5的async/await实现异步
热门推荐
OSKernelLAB(gatieme)
01-23 1万+
async/await异步功能简介从4.0版本开始.NET引入并行编程库，用户能够通过这个库快捷的开发并行计算和并行任务处理的程序。在4.5版本中.NET又引入了Async和Await两个新的关键字，在语言层面对并行编程给予进一步的支持，使得用户能以一种简洁直观的方式实现并行编程。因为在很多文档里针对Async和Await这两个关键字的使用都被称为异步编程，为了更符合大众的阅读习惯，我们使用异步编程
深入理解Async/Await
dotNET跨平台
03-01 1117
C# 5 Async/Await 语法特性，极大地简化了异步编程，但我们知道，异步编程的基本原理并没有发生根本改变。也就是说，当一些复杂的东西看起来很简单时，它通常意味着有一些有趣的事情在背后发生。
async和await面试题
最新发布
08-28
下面是一些关于async和await的面试题： 1. async和await是什么？它们的作用是什么？ - async是用来声明一个函数是异步的，它会返回一个Promise对象。 - await用于等待一个Promise对象的解析结果，并且只能在async...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值