<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>Async on 菜菜博士</title>
    <link>https://microcai.org/tags/async.html</link>
    <description>Recent content in Async on 菜菜博士</description>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <lastBuildDate>Sun, 15 Dec 2024 00:00:00 +0800</lastBuildDate>
    <atom:link href="https://microcai.org/tags/async/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>基于 ucontext &#43; iocp4linux 的超简协程库</title>
      <link>https://microcai.org/2024/12/15/ucontext-based-uasync.html</link>
      <pubDate>Sun, 15 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/15/ucontext-based-uasync.html</guid>
      <description>&lt;p&gt;虽然说，使用 异步最佳的实践是使用协程。&lt;/p&gt;
&lt;p&gt;然而 c++20 的协程并不总是可用的。总不能说，不能更新编译器的地方就不配写代码吧。&lt;/p&gt;
&lt;p&gt;因此，我在上一篇文章里说道，可以继续忍受回调地狱。或者使用有栈协程。&lt;/p&gt;
&lt;p&gt;当然，如果使用 asio ， 那么一切问题都不存在。asio 支持 有栈协程，无栈协程，daff‘s device 协程，还有最基础的，回调模式。
asio 简直就是个“宇宙级” 的异步库。&lt;/p&gt;
&lt;p&gt;然而，asio 也并不总是可用。&lt;/p&gt;
&lt;p&gt;于是，基于 ucontext 的一个超简协程库就应运而生。&lt;/p&gt;
&lt;p&gt;首先，这个不是一个独立的库，他其实顺手带在 uasync 里。作为  universal_fiber.h 头文件提供。&lt;/p&gt;
&lt;p&gt;就隐藏在 iocp4linux 的 example 代码里。
见 &lt;a href=&#34;https://github.com/microcai/iocp/blob/master/example/echo_server/echo_server_stackfull.c&#34;&gt;echo_server_stackfull.c&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;没错，这次是个 C 代码。尽管我非常讨厌 C。&lt;/p&gt;
&lt;p&gt;这个库，只是为了演示如何将 proactor 和有栈协程给结合起来。虽然我本人建议最好使用 c++20 的协程。但是总有人是升级不了编译器的。
因此我再三思考后，决定还是写一个小 demo 来演示 proactor 和有栈协程 如何极便捷的结合。&lt;/p&gt;
&lt;p&gt;对于这么一个简单的 echo server 例子，作为对比，同文件夹下的 echo_server_callback.cpp 就是基于回调的。可以直观感受下，基于回调和基于协程的代码可读性。&lt;/p&gt;
&lt;h1 id=&#34;先看有栈和无栈例子对比&#34;&gt;先看有栈和无栈例子对比&lt;/h1&gt;
&lt;p&gt;这个是 echo server 左边有栈协程和右边无栈协程的 accept 循环的代码对比
&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ucontext_code4.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;不能说毫无差别，简直可以说是一模一样&lt;/p&gt;
&lt;p&gt;也就是说有栈和无栈，是只存在底层工作机制的差异&lt;/p&gt;
&lt;p&gt;没有使用上的差异。&lt;/p&gt;
&lt;p&gt;这就是 universal_fiber.h 和 universal_async.hpp 的威力。&lt;/p&gt;
&lt;p&gt;关于那个无栈协程 universal_async.hpp 的分析，参考 &lt;a href=&#34;https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html&#34;&gt;这篇文章&lt;/a&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入异步IO 第二篇： 正确使用 IOCP，正确设计 proactor</title>
      <link>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</link>
      <pubDate>Sat, 14 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;reactor-和-proactor&#34;&gt;Reactor 和 Proactor&lt;/h1&gt;
&lt;p&gt;ACE 作者当年提出了数个高性能网络IO的模型，其中将这些模型总结为 Reacto 和 Proactor。如果按字母意思翻译，
则称为 反应器 和前摄器。&lt;/p&gt;
&lt;p&gt;但是，我更愿意使用更精准的汉语表达：多路复用模式 和 重叠IO模式。&lt;/p&gt;
&lt;h2 id=&#34;多路复用模式&#34;&gt;多路复用模式&lt;/h2&gt;
&lt;p&gt;前一篇文章说道，要想实现单线程并发IO, 内核必须要提供的2个机制。在 多路复用模式下，要求的机制就是&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 和 &lt;strong&gt;无阻塞IO操作&lt;/strong&gt;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;无阻塞IO操作&lt;/strong&gt; 要求内核在IO不能立即完成的情况下，不能挂起调用线程，而是返回错误。但是此时代码不应该进入无限重试，而是等待内核的通知。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 如果一个 IO 操作接下来可以无阻塞立即执行，则通知程序，现在可以干活而不会失败了。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;比如我写一个 server，调用 read() 读取客户端发送的数据。如果客户端还未发送数据。则内核会挂起线程直到对方发送数据。然后 read 就执行成功并返回了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入理解异步IO</title>
      <link>https://microcai.org/2024/12/13/in-deepth-async.html</link>
      <pubDate>Fri, 13 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/13/in-deepth-async.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;线程的由来&#34;&gt;线程的由来&lt;/h1&gt;
&lt;p&gt;现在的程序员大部分都是新世纪后出生的。所以早就忘记了线程的设计初衷了。我看到大部分新世纪程序员都说线程是为了并发，为了压榨cpu的性能。&lt;/p&gt;
&lt;p&gt;其实多线程压榨 cpu 的性能，是最近十几年才有的。而线程的历史，和操作系统一样古老。
计算机诞生的前半个世纪，CPU都是单核的。那时候就已经有了多线程。&lt;/p&gt;
&lt;p&gt;所以，线程的最初真正作用，实际上出乎现在的程序员的意料：是为了实现异步IO。&lt;/p&gt;
&lt;h2 id=&#34;dos-下的-io&#34;&gt;DOS 下的 IO&lt;/h2&gt;
&lt;p&gt;在个人电脑的上古时代，一个打字员的日常工作，是打字，然后 按下键盘上的 Ctrl-S。接着去泡杯茶去喝。&lt;/p&gt;
&lt;p&gt;当 wps 要将文档存入软盘，意味着这段时间，整台电脑都处于“不可操作”的状态。
直到软驱磁头吭呲吭呲的干完活，当前的应用才会复活，能继续执行其他任务了。&lt;/p&gt;
&lt;p&gt;为啥会这样呢？因为 DOS 是一个单任务的操作系统，不支持多线程。这就意味着，DOS 不支持异步 IO。WPS要写磁盘，就只能等待 DOS 完成文件写入。
期间整个电脑都无法干其他工作。&lt;/p&gt;
&lt;p&gt;这个问题，直到“多任务系统”的出现才解决。当然，多任务系统，出现的比 DOS 早多了，只不过，引入 PC 领域要晚的多。一直到 windows 出现。&lt;/p&gt;</description>
    </item>
    <item>
      <title>批量提交IO提升性能</title>
      <link>https://microcai.org/2024/12/10/io_batching-boost-performance.html</link>
      <pubDate>Tue, 10 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/10/io_batching-boost-performance.html</guid>
      <description>&lt;p&gt;在基本完成 iocp4linux 后，我抽空在 &lt;a href=&#34;https://wiki.radxa.com/Rockpi4&#34;&gt;rockpi&lt;/a&gt; 上测了下性能。&lt;/p&gt;
&lt;p&gt;使用仓库里自带的例子  test/web_server/server.cpp，我测得了大约 6000req/s 的性能。&lt;/p&gt;
&lt;p&gt;还不错。但是和 PC 上超过十万的性能相比，有那么点。。。弱鸡。&lt;/p&gt;
&lt;p&gt;但是我通过 htop 注意到了一点。wrk 压测的时候， cpu1 是 cpu 100%。而且都是 红色的。说明cpu 都花在内核时间上了。
这也是 io_uring 很牛逼的原因：活都让内核干了。&lt;/p&gt;
&lt;p&gt;==。&lt;/p&gt;
&lt;p&gt;rockpi 是个6核的soc, 其中 cpu1-cpu4 （我设定 htop 的 cpu 从 1 开始数。）是个 1.4Ghz 的小核。cpu5，cpu6 才是 1.8Ghz 的大核。&lt;/p&gt;
&lt;p&gt;这 不仅仅一核有难，5核围观。这特么干活的还是个小核。&lt;/p&gt;
&lt;p&gt;于是果断找原因，发现是中断亲和性的设定问题。将中断迁移到 cpu5 后，测试发现干活的就是 1.8Ghz 的大核啦。&lt;/p&gt;
&lt;p&gt;然后性能飙到超过 9000req/s。&lt;/p&gt;
&lt;p&gt;之前测试的性能忘记记录了，这次随手截图留存了。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/iocp4linux_perf_1.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;嘿嘿，果然给力。这优化。还是免费的。&lt;/p&gt;
&lt;p&gt;就在我沾沾自喜的时候，我又随手测试了以下 老中医写的 proxy_server。它里面带了一个简单的 http server。
wrk 压测以下，我了个去的。轻轻松松 1.6万req/s。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/asio_test1_perf.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;asio 你大爷还是你大爷！&lt;/p&gt;
&lt;p&gt;于是我琢磨着进行优化。&lt;/p&gt;
&lt;p&gt;我想到了 io_uring 提交 IO 的两步曲：&lt;/p&gt;</description>
    </item>
    <item>
      <title>超轻量级 IOCP 协程库</title>
      <link>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</link>
      <pubDate>Sun, 08 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/12/04/iocp-on-linux.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我提出了 &lt;a href=&#34;https://github.com/microcai/iocp&#34;&gt;iocp4linux&lt;/a&gt; 。&lt;/p&gt;
&lt;p&gt;在编写 iocp4linux 的过程中，我需要写一些测试代码。&lt;/p&gt;
&lt;p&gt;一开始，我随便的找了一个基于 IOCP 的 echo test 和一个简单的 web server。
首先确保这弄来的例子能在 windows 上编译通过。&lt;/p&gt;
&lt;p&gt;然后修改 ifdef _WIN32守卫，在 linux 平台上改为使用 iocp.h 头文件。&lt;/p&gt;
&lt;p&gt;然后很轻松的就移植到 linux 上了。&lt;/p&gt;
&lt;p&gt;但是，我对于这些 C 风格的 demo 并不满意。因为我完全改不动他们的代码。&lt;/p&gt;
&lt;p&gt;于是，我想着，何不写一个超级轻量级的一个封装库？
这个库，应该做到跨平台 —— 指能同时兼容原版 windows.h和 iocp.h。然后代码尽量短小，同时又足够易用。&lt;/p&gt;
&lt;p&gt;最后。我折腾出了一个超轻量级的协程库。&lt;/p&gt;
&lt;p&gt;废话不说，先看一段 异步 accept 的代码：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/awaitable_overlapped.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;在红框处，使用的是 windows 上的异步 accept 。
在 AcceptEx 调用的时候，传入了一个 ov 对象。
这个 ov 对象，类型是 awaitable_overlapped 。
awaitable_overlapped 可以隐式转换为 &lt;code&gt;WSAOVERLAPPED*&lt;/code&gt; 从而被 AcceptEx 所接受。&lt;/p&gt;
&lt;p&gt;由于是异步 IO ， 这时代码会继续向下运行。一般如果是在非协程的代码里。此时就应该返回函数。&lt;/p&gt;
&lt;p&gt;然后把 accpet 的后续逻辑，放到 调用 &lt;code&gt;GetQueuedCompletionStatus&lt;/code&gt; 的事件循环里了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>IOCP 移植到Linux上</title>
      <link>https://microcai.org/2024/12/04/iocp-on-linux.html</link>
      <pubDate>Wed, 04 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/04/iocp-on-linux.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;windows 高性能IO使用的是 proactor 模型，而古代 Linux 上则是 reactor 模型。&lt;/p&gt;
&lt;p&gt;因此跨平台的网络库，通常会选择实现为其中一种模型，然后在另一个平台上使用模拟。
比如 asio 使用 proactor 模型。Linux 上使用 epoll 模拟。
又比如 libevent 使用 reactor 模型， windows 上使用 iocp 模拟。&lt;/p&gt;
&lt;p&gt;而将 iocp 模拟为 epoll 的库，就是 &lt;a href=&#34;https://github.com/piscisaureus/wepoll&#34;&gt;wepoll&lt;/a&gt; 了。&lt;/p&gt;
&lt;p&gt;但是，reactor 比较是一种比较落后的模型。因此，进行跨平台封装为 proactor 实际上是更先进的做法。&lt;/p&gt;
&lt;p&gt;虽然已经有 asio 这种 proactor 库了，但是毕竟 asio 是一个比较重量级的库。一种轻量级的 proactor 库
也是非常有市场的。&lt;/p&gt;
&lt;p&gt;更何况，既然有 wepoll 这种把 Linux api 弄到 windows 上的库，那没有 Linux IOCP 就说不过去了。&lt;/p&gt;
&lt;p&gt;于是我决定，开发一个 Linux 版的 IOCP 库。这样方便使用 IOCP 开发的各种软件可以方便的迁移到 Linux 平台。而无需重写。&lt;/p&gt;
&lt;h1 id=&#34;如何实现呢&#34;&gt;如何实现呢？&lt;/h1&gt;
&lt;p&gt;如果是在很久以前，这件事其实还是比较复杂的。然而，嘿嘿。从 linux 5.1 开始，一个崭新的名为 io_uring 的系统接口诞生了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>用iouring扩展asio</title>
      <link>https://microcai.org/2024/11/21/extending-asio.html</link>
      <pubDate>Thu, 21 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/21/extending-asio.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;什么叫扩展asio？
Beast给Asio增加了 HTTP 协议，不叫扩展asio。那什么叫扩展asio？
举个例子，给 asio 的 socket 对象，基于io_uring提供的 IORING_OP_SHUTDOWN 增加 async_shutdown() 接口，就算扩展asio。因为原本asio并没有异步shutdown功能。而且这个功能并不能靠组合原有的asio接口实现。这就叫扩展asio。&lt;/p&gt;
&lt;p&gt;扩展asio, 又不能修改asio的代码。看起来有点难办。
好在，asio的设计也是有一定的扩展性的，并非完全依赖修改源码实现扩展。
但是不可避免的，需要使用 asio::detail:: 名字空间下的非公开接口。&lt;/p&gt;
&lt;p&gt;那么，就从 async_shutdown 开始，讲解如何扩展asio吧！&lt;/p&gt;
&lt;h1 id=&#34;接口形式&#34;&gt;接口形式&lt;/h1&gt;
&lt;p&gt;不修改asio代码的大前提下，要给一个对象增加一个 async_shutdown() 的成员函数那是痴人说梦。语言上就禁了此路。&lt;/p&gt;
&lt;p&gt;不过，有两种绕过的做法&lt;/p&gt;
&lt;p&gt;其一。写一个新的socket对象，自 asio::ip::tcp::socket 继承。然后增加一个成员函数。缺点是所有使用 socket 的地方都得修改一下类型。有了IDE的重构大法，实际上为了能异步关闭而进行的迁移并不算特别大的工作量。但是如果有不需要牵一发而动全身的修改，会更好。
其二。写一个全局函数，接受一个 asio::ip::tcp::socket 并将他异步关闭。&lt;/p&gt;
&lt;p&gt;第二个方法，不需要对整个项目进行大手术。只需要在需要异步关闭的地方，将原来的同步关闭 ( &lt;code&gt;socket.shutdown();&lt;/code&gt;)，替换为  &lt;code&gt;co_await async_shutdown(socket, defered);&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;从设计美学上来说，第二个方法更好。&lt;/p&gt;
&lt;h1 id=&#34;操作系统接口&#34;&gt;操作系统接口&lt;/h1&gt;
&lt;p&gt;扩展asio, 并不是使用asio现有接口去实现一个功能。比如beast利用 asio现有的socket接口就能实现在其基础上增加 HTTP 协议支持。
我们要给 asio 的 socket 增加异步关闭功能，是实打实的让asio多了原本不存在的功能。那么显然，这样的功能，首先我们得问一问，操作系统支持吗？
如果操作系统不支持一个功能，我们想破天也没法给asio扩展出这个功能。&lt;/p&gt;
&lt;p&gt;答案是，异步关闭socket只有io_uring支持了。windows 上虽然也支持异步关闭，但是需要使用 WSAEventSelect + WSAWaitForMultipleEvents + shutdown 组合使用。IOCP不支持异步关闭。没有能传 overlaped* 的 WSAShutdown 版本。&lt;/p&gt;
&lt;h1 id=&#34;asio-的接口组织结构&#34;&gt;asio 的接口组织结构&lt;/h1&gt;
&lt;p&gt;asio 暴露给用户的接口为2种对象，其一为 executor ，其二为 io_object. executor 一般而言就是 asio::io_context。而 io_object 则通常就是 socket 咯。&lt;/p&gt;</description>
    </item>
    <item>
      <title>重叠IO（proactor）是最理想的IO模型</title>
      <link>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</link>
      <pubDate>Tue, 19 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</guid>
      <description>&lt;p&gt;reactor 和 proactor ， 这种毫无联系的英文专用名词，很容易把人弄晕。&lt;/p&gt;
&lt;p&gt;回归正途，使用精确的汉语描述，而非翻译，则正确的说法是：&lt;/p&gt;
&lt;p&gt;多路复用IO 和 重叠 IO 模式。&lt;/p&gt;
&lt;p&gt;所谓多路复用，顾名思义，就是好几个IO复用。。。 复用了谁？复用了线程。
它对比的是最传统的UNIX网络编程： 一个连接一个线程。并发就要开多线程。连接多了，线程就多，系统压力非常大。
而多路复用，则可以让一个线程处理多个连接。这就是复用的含义。为了实现复用，首先IO是非阻塞的。因为如果阻塞了线程，其他连接上的数据不就没法处理了么。既然非阻塞，那就会出现网络数据没准备好，就一直返回 EAGAIN 错误。一直返回难道一直重试吗？显然不现实。所以就有了一个 多路复用器。这个多路复用器最早是 select() 调用。后来是 poll() 最后是 epoll().
而重叠IO,顾名思义，就是 IO 操作是重叠的。和什么重叠？当然是和你当前的线程是重叠的。
也就是，向系统提交一个 IO 操作， 系统就会在“后台”默默的干苦力，当前线程可以立即执行其他任务。不会被阻塞。他和多路复用模式的区别是，多路复用模式，如果会阻塞，内核就返回会阻塞，而不是在后台默默干活。而 重叠IO 则即不会阻塞，也不会返回“请重试”。而是在后台开始默默的进行处理。这个IO的处理，和你程序本身的逻辑，是重叠进行的。所以叫重叠IO。&lt;/p&gt;
&lt;p&gt;话又说回来了，系统是在后台干活了，你得知道他啥时候干好了吧？总不能两眼一摸黑，不知道了吧。
因此，系统需要一个通知机制。Linux 这边，曾经有一种叫 AIO 的东西，它用 “信号” 来通知 IO 完成了。而如今 Linux 使用 io_uring 的 无锁列队 来完成通知。而 windows 则使用 一个叫“完成队列”的东西来通知，当然也可以使用 窗口消息来通知结果。&lt;/p&gt;
&lt;p&gt;不管是 win 的窗口消息，还是linux的 AIO ，在实践中都被人抛弃不用了。因此不讨论这些。&lt;/p&gt;
&lt;p&gt;我们讨论 IO完成端口，和 io_uring, 他们本质上是一样的，就是提供一个异步队列，然后应用层可以使用 一个或多个线程，去读取这个队列获得完成通知。每一个IO操作，都对应一个完成通知。
因此，重叠IO模式，其实和传统的编程思路是一致的：每调用一个函数，就获得一个返回值。
无非是，这个返回不是通过 ret 指令返回，返回结果也不是通过 EAX 寄存器返回。
而是存放到了一个消息队列里。&lt;/p&gt;
&lt;p&gt;但是，操作请求和结果返回，是一一对应的。这是一种非常自然的概念。
自然而然的，在编程上，就可以设计为 IO发起 + 完成回调。
库的作用，就是封装 系统的 IO api ，然后将 IO完成消息转化为 完成回调。
有了 IO发起+完成回调。很自然的，程序就可以组织为一种 协程结构。 发起IO操作，返回一个 promise . IO完成就是让 promise 完成状态。
想同步IO结果，只要 await 这个 promise 就可以了。
非常的容易理解，而且封装起来也非常的轻松。用起来简直就是爽到high起。&lt;/p&gt;</description>
    </item>
    <item>
      <title>真正的重叠IO</title>
      <link>https://microcai.org/2024/11/18/real-overlaped-io.html</link>
      <pubDate>Mon, 18 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/18/real-overlaped-io.html</guid>
      <description>&lt;p&gt;不知有没有人想过，为何微软将windows 的异步API称为“重叠IO”而不是异步IO。&lt;/p&gt;
&lt;p&gt;在我看来，重叠IO和异步IO的区别，主要在于发起IO后的动作。&lt;/p&gt;
&lt;p&gt;重叠IO, 发起 IO 后，继续执行应用层的逻辑。应用可以选择在任何何时的地点再选择同步（阻塞等待 or 异步等待）IO的结果。
异步IO, 发起 IO 后，立即挂起当前业务逻辑（也就是立即非阻塞等待 IO 结果），回到事件循环，以便执行其他业务逻辑。&lt;/p&gt;
&lt;p&gt;放到协程的设计角度，重叠 IO 相当于这样使用&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;async&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;function&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;file&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;read&lt;/span&gt;(...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    ... &lt;span style=&#34;color:#a6e22e&#34;&gt;干点不依赖&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;结果的事情&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_result&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;await&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    ... &lt;span style=&#34;color:#a6e22e&#34;&gt;干需要&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;操作结果的事情&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;而异步 IO, 则是这样使用&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; function &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; read_result &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; co_await file.&lt;span style=&#34;color:#a6e22e&#34;&gt;async_read&lt;/span&gt;(...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// do other logic.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以看出来，重叠 IO 在发出 IO 操作后，可以继续执行其他逻辑。只有当确实需要数据的时候，再进行等待。
而异步IO模式下，发出IO后，必须立即挂起当前协程等待IO完成。&lt;/p&gt;
&lt;p&gt;那么，这两种差异，对现实中的程序有什么影响呢？&lt;/p&gt;
&lt;p&gt;我们先考虑一个最简单的应用： 静态 web 服务器。&lt;/p&gt;
&lt;p&gt;在静态web服务器里，最核心的处理逻辑，就是找到用户要下载的文件，然后将文件发送给客户端。伪代码如下&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; handle_send_file(&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; target, &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; socket)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt; buffer[&lt;span style=&#34;color:#ae81ff&#34;&gt;65536&lt;/span&gt;];
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    fs&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;file f(target, flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;binary&lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt;flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;open);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;long&lt;/span&gt; total &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt;(;;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; read_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; f.async_read_some(buffer);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (read_size &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            &lt;span style=&#34;color:#66d9ef&#34;&gt;break&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        total &lt;span style=&#34;color:#f92672&#34;&gt;+=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; socket.async_write_some(buffer, read_size);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;co_return&lt;/span&gt; total;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个代码里，主要的逻辑就是 循环读取文件，然后发送。&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
