一个下载服务,线程池固定 8 条线程,平时 QPS 很稳。某天对象存储的响应从 20 毫秒涨到 300 毫秒,QPS 直接掉到原来的十分之一,CPU 却几乎空闲。开发第一反应是“下游慢了,加机器”,加了四台之后 QPS 只涨了一点,线程还是不够用。

问题不在算力,在等待方式。每条线程发起一个网络读取,然后阻塞在那里,直到对方返回。等待期间它什么都不做,但也不能被别的请求复用。8 条线程意味着最多 8 个请求同时在等,下游一慢,等待时间变长,吞吐自然被压死。

这篇讲五种 IO 模型,重点不是背名词,而是搞清楚两件事:谁在等、等的时候线程能不能干别的。最后会落到平台差异和选型上,因为同样叫 select,不同系统的行为和限制并不一样。

现象:线程都卡在等,CPU 帮不上忙

先建立一个判断:如果 CPU 不高、线程数满了、请求排队变长,瓶颈大概率在等待,不在计算。加机器只能增加等待的并发数,不能减少单次等待的时间;下游延迟不降,吞吐的上限就还在那里。

阻塞 IO 的模型很直观:调用读取,线程进入等待,数据准备好后内核唤醒它,再把数据交回来。代码简单,顺序清晰,适合并发不高、逻辑复杂的场景。它的代价是“一条线程同一时间只能盯一个等待”,线程数就是并发上限。

当等待时间远大于处理时间时,线程大部分时间都在睡。线程池看起来开得很大,实际有效吞吐并不高,因为每条线程都被一个慢请求占着。更糟的是,慢请求会占满线程池,把后面的快请求一起堵住。

这里有一个简单的估算:并发数大致等于每秒请求数乘以平均延迟。下游延迟从 20 毫秒涨到 300 毫秒,同样的线程数能支撑的 QPS 就会掉到原来的十几分之一。这不是线程池配置突然变差了,而是每个请求占住线程的时间变长了。算清这个关系,就能判断该加并发、该降延迟,还是该换等待模型。

场景走查:一次读取到底在等什么

把一次网络读取拆开,看清楚等待发生在哪一步。

一次读取的等待路径
发起调用线程请求读取,进入内核
检查数据内核发现接收缓冲区里还没有数据
挂起等待把线程放进等待队列,让出 CPU
数据到达网卡收到包,中断处理把数据放进缓冲区
唤醒线程内核把线程标为就绪,等调度器选它
复制返回把数据从内核缓冲区复制到用户空间

关键在第三步。线程没有在“等数据”,它在等待队列里睡着,CPU 被让给别的线程。这个让出本身是好事,问题在于唤醒之前,这条线程不能做任何别的事。它被绑定在这次读取上。

第五步也有延迟。数据到了不等于线程立刻跑,它只是变成就绪,还要排队等调度。高并发时,就绪队列很长,唤醒到真正执行之间又有一段等待。这就是为什么“下游只慢了一点”,端到端延迟会放大更多。

第六步是数据复制。内核缓冲区到用户缓冲区通常要复制一次,大块数据会明显增加开销。零拷贝技术就是在这步做文章,但它改变的是复制次数,不改变等待模型。

阻塞与非阻塞:等不等,差别在哪

阻塞调用的语义是“没数据就等”,非阻塞调用的语义是“没数据就立刻告诉你没有”。后者的返回值通常是一个特定的“暂时不可用”错误,程序需要自己决定下一步:过一会儿再试、去处理别的连接,或者交给多路复用接口统一等待。

非阻塞并不自动带来高吞吐。如果程序写成“没数据就立刻再试”,它会陷入忙轮询,把 CPU 烧在一个永远还没准备好的连接上。正确用法是把多个非阻塞连接交给一个统一的通知机制,只在真正就绪时才去读。这个机制就是多路复用。

阻塞式

代码直观,一条线程一个连接,读起来像顺序程序。并发靠加线程,线程数就是并发上限。适合连接数不大、逻辑复杂的服务。

慢请求会占住线程,线程池容易被拖死;线程太多又会增加栈内存和切换开销。

非阻塞加多路复用

一个线程可以盯很多连接,只在就绪时处理。连接数可以很大,线程数可以很小。代价是代码要围绕事件组织,状态机、缓冲区和错误处理都更复杂。

它适合大量长连接、IO 密集的服务;不适合把普通文件读取也硬塞进来,原因后面会讲。

多路复用:一次等待,多个连接

多路复用的核心是“把多个等待合并成一次等待”。程序把一组连接交给内核,说“其中任何一个可读或可写,就叫我”。内核挂起一次,等有事件时返回就绪列表,程序再逐个处理。

最早的接口是 select。它用一个位图表示关心的连接,调用时把位图交给内核,返回时内核改写位图表示哪些就绪。问题有三个:连接编号有上限,数量大时每次都要复制和扫描整个位图,返回后还要自己再遍历一遍找就绪项。

poll 把位图换成了数组,取消了固定上限,但“每次扫描全部”的问题还在。连接数上万时,即使只有几个活跃,程序也要为所有连接做检查,开销随总数增长。

epoll 换了个思路:连接注册一次,内核维护一张表,就绪的连接放进一个单独的列表。程序等待时只拿就绪列表,不需要每次扫描全部。它在 Linux 上是高并发网络服务的常用选择。BSD 和 macOS 用 kqueue,思路类似。

Windows 的对应方案是完成端口(IOCP)。它不是“就绪通知”,而是“完成通知”:程序先发起一个异步读取,读完了内核再通知你,并附上结果。这个差别很重要,后面单独讲。

多路复用还有触发模式的差别。水平触发像“水位没降就继续报警”:只要缓冲区里还有数据,下一次等待还会通知你。边缘触发像“只在状态变化时报一次”:从没数据变成有数据时通知,之后不再重复。边缘触发减少了重复通知,但要求程序一次把能读的数据读干净,否则剩下的数据可能等不到下一次事件。这个细节是很多事件驱动程序的 bug 来源。

就绪与完成:两种完全不同的思路

select、poll、epoll 给的是就绪通知:它告诉你“现在读不会阻塞”,但真正的读取还要你自己调用。异步接口给的是完成通知:它告诉你“读取已经做完,数据在这里”。前者把“等”和“做”分开,后者把两者合并成一次提交。

完成通知的好处是省掉一次“先问再读”的往返,尤其适合高延迟设备。坏处是编程模型更复杂:要管理请求上下文、缓冲区生命周期、完成顺序,还要处理取消和超时。就绪通知的模型更接近传统写法,但需要自己处理“读了一半”“暂时没数据”的情况。

还有一个常被忽略的点:多路复用主要针对套接字、管道这类“会等待”的对象。普通文件读取通常不会因为“数据没准备好”而长期等待,文件系统会让读取直接返回,或者在内核里排队。把普通文件塞进 epoll,往往总是“就绪”,起不到合并等待的作用。磁盘 IO 想真正异步,需要专门的文件异步接口。

实测:非阻塞读与一次 selector 等待

用 Python 建一对本地套接字,先把一端设为非阻塞,在没有数据时读一次;再用 selector 注册可读事件,从另一端发送数据,观察事件返回。

import socket, selectors

a, b = socket.socketpair()
a.setblocking(False)
try:
    data = a.recv(1024)
    print("nonblocking recv returned:", data)
except BlockingIOError:
    print("nonblocking recv: BlockingIOError (no data yet)")

sel = selectors.DefaultSelector()
sel.register(a, selectors.EVENT_READ)
b.send(b"hello")
events = sel.select(timeout=1.0)
print("selector events:", len(events))
for key, mask in events:
    print("ready to read:", a.recv(1024))

本机 Python 3.15、Windows 环境实际输出:

nonblocking recv: BlockingIOError (no data yet)
selector events: 1
ready to read: b'hello'
SelectSelector available: True
PollSelector available: False
EpollSelector available: False

前两行说明非阻塞读在没有数据时立刻返回,不会卡住线程。第三、四行说明 selector 等到可读事件后才去读,读到了内容。最后三行是平台差异:Windows 上 Python 的 selector 默认只能用 select,poll 和 epoll 不可用;Linux 上则可以用 epoll,BSD 系可以用 kqueue。同一套接口名字,底下的能力和限制并不一样。

这个实验规模很小,但把模型分清楚了:非阻塞解决“不要卡住”,多路复用解决“一个线程怎么盯很多个”。两者通常一起用,单独用非阻塞会变成忙轮询,单独用阻塞则回到一线程一连接。

还要注意,select 的连接编号上限在不同平台不一样,Windows 上通常更小,Linux 上可以通过调整提高,但提高之后扫描成本也更大。连接数上万时,select 和 poll 的线性扫描会成为瓶颈,这也是 epoll 被设计出来的直接原因。它不是“更快的 select”,而是换了一种只返回就绪项的数据结构。

现象对照表

现象真实原因第一步查什么
下游变慢,线程池迅速耗尽阻塞 IO 让线程绑定在单次等待上看线程栈是否都停在读写调用,统计等待时间占比
CPU 不高,吞吐上不去瓶颈是等待并发数,不是计算能力算一下并发上限和平均等待时间,判断是否被线程数卡住
改成非阻塞后 CPU 反而升高写成了忙轮询,没有统一等待检查循环里是否不断重试,改成事件驱动
连接数一多,select 明显变慢每次调用都要复制和扫描全部连接看连接总数和活跃比例,考虑 epoll 或 kqueue
epoll 注册普通文件后总是就绪普通文件读取不遵循套接字那种等待语义确认对象类型,磁盘异步要换专门的接口
边缘触发模式下漏事件只读了一次,没把缓冲区读空检查是否循环读到暂时无数据,或改用水平触发
Windows 上 poll/epoll 不可用平台接口不同,对应方案是完成端口确认运行平台和运行时封装,不要照搬 Linux 代码
异步接口代码复杂、bug 多完成通知要管理上下文、缓冲区和取消先评估是否真的需要异步,能否用成熟框架封装

边界与代价

多路复用把等待集中了,但没有消除等待,也没有消除复制。它降低的是“每条连接一条线程”的固定成本,换来的是事件驱动代码的复杂度。连接数不大时,阻塞加线程池往往更简单、更好维护;连接数很大、等待很长的场景,才值得付这份复杂度。

事件驱动还有几个现实坑。水平触发会反复通知,直到你把数据处理完;边缘触发只在状态变化时通知一次,漏读就可能永远等不到下一次。缓冲区要自己管理,读一半、写一半、对端关闭都要单独处理。稍不留神,就会出现“看起来连上了,实际永远收不到数据”的问题。

异步接口的代价更高。它要求你把每次操作拆成“提交”和“完成”两段,中间的状态要自己保存;取消、超时、错误传播都比同步代码难写。很多团队最后选择用协程或运行时封装,把异步的复杂度藏起来,保留同步写法。这不是偷懒,是把复杂度集中到一处,而不是散落在每个业务函数里。

平台差异也必须算进成本。Linux 的 epoll、BSD 的 kqueue、Windows 的 IOCP,语义和限制都不同。跨平台框架会做一层抽象,但抽象难免丢掉一些细节,比如边缘触发、批量提交、零拷贝。选框架之前,先确认它在你关心的平台上到底用了什么。

还有一条折中路线值得知道:保留阻塞写法,但让运行时来承担等待。协程、绿色线程、虚拟线程都属于这一类,代码看起来是同步阻塞的,底下由运行时把等待挂起,再在事件就绪时恢复。它把复杂度从业务代码移到了运行时,写起来接近传统线程模型,扩展性又比一线程一连接好。代价是运行时本身更复杂,某些阻塞调用仍会卡住底层线程,排查问题时需要理解两层调度。

选型时别只比峰值吞吐,还要比故障时的可观测性。事件驱动程序一旦卡住,线程栈里往往看不出它在等哪个连接;阻塞程序虽然扩展性差,但线程栈能直接告诉你卡在哪一行。团队更熟悉哪种模型,往往比理论上的最优模型更重要。

当天能自己验证的练习

  1. 运行上面的 Python 实验,把非阻塞读改成阻塞读,在没有数据时观察程序是否卡住;再用另一个线程发送数据验证。
  2. 把 selector 注册的连接数从 1 增加到 100,测量一次等待的耗时,观察平台差异。
  3. 写一个忙轮询版本的非阻塞读取,统计一秒内的循环次数和 CPU 占用,再和 selector 版本对比。
  4. 用 socketpair 模拟慢速对端:一端延迟发送,另一端用阻塞和非阻塞两种方式读,观察线程状态和总耗时。
  5. 在 Linux 上分别用 select、poll、epoll 处理一万个连接,比较就绪很少时的 CPU 占用。本机没有 Linux 环境,这一条未在本机实测。

小结

阻塞 IO 让线程睡在等待上,代码简单但并发受线程数限制;非阻塞 IO 立刻返回,单独使用会变成忙轮询;多路复用把多个等待合并成一次,适合大量长连接;异步接口给的是完成通知,省掉一次往返,但编程模型更复杂。普通文件和多路复用的语义不匹配,磁盘异步要走专门接口,平台之间也有实打实的差异。

选型的顺序应该是:先看连接数和等待时间,再看团队对事件驱动的熟悉程度,最后看平台支持。不要因为“epoll 听起来高级”就把一个几十连接的服务改成事件驱动,也不要因为“阻塞写起来简单”就让线程池去扛上万长连接。模型没有高下,只有匹配不匹配。

操作系统这一组到这里就结束了。下一篇进入二进制与数据表示,从最底层的位和字节开始:为什么一个字节是 8 位、整数在内存里长什么样、浮点数为什么会丢精度。上面这些 IO 和内存机制,最终都要落到这些字节上。