一、问题的由来
写过网络服务的人,大概都遇到过这种情况:服务器 CPU 和内存都很闲,但并发连接一多,服务就卡住了。
这是为什么?
原因在于阻塞 IO 的模型。一个线程服务一个连接,recv 一调用,线程就挂起,数据不来,它就一直等。一万个连接,就要一万个线程。可是真正有数据的,可能只有几十个。剩下九千多个线程,什么也不干,就挂在那里等。
线程要占内存,内核要维护等待队列,调度器还要在它们之间来回切换。CPU 的时间,全花在"管理等待"上,而不是"处理请求"上。
这就是 C10K 问题。不是 CPU 算不动,是线程等不起。
解决办法叫 IO 多路复用。思路很简单:不要每个连接配一个线程,而是把所有 fd 交给一个管家,谁有动静了,管家通知你。你只处理真正就绪的那几个。
管家有三种当法:select、poll、epoll。下面我们一个一个说。
二、select
select 是最老的接口,POSIX 标准,几乎每个 Unix 系统都有。
用法是传三个 fd 集合进去(读、写、异常),内核帮你盯着。哪个就绪了,就在集合里标记出来。你遍历集合,找出是谁。
go
var readfds unix.FdSet
unix.FdZero(&readfds)
for _, fd := range conns {
unix.FdSet(fd, &readfds)
}
// 返回后 readfds 被内核改写,只剩就绪的 fd
n, _ := unix.Select(maxfd+1, &readfds, nil, nil, nil)
for fd := 0; fd <= maxfd && n > 0; fd++ {
if unix.FdIsSet(fd, &readfds) {
n--
// 处理这个 fd
}
}
select 有两个问题。
第一个是 FD_SETSIZE。Linux 上通常是 1024。fd 集合是一个固定大小的位图,你想监控第 1025 个 fd?POSIX 说这行为未定义。 也就是说,select 从设计上,就不可以做到超过一千个连接。
第二个是性能。每次调用 select,你都要把整个 fd 集合从用户空间拷进内核,内核再从头到尾扫一遍。 哪怕 1000个 fd 里只有1个有数据,另外999个也要检查。开销是 O(总连接数)。
还有一个细节,容易踩坑:select 返回后,你传进去的集合被内核改过了,里面只剩就绪的那些。 下一次调用前,必须重新 FdSet 全部关心的 fd。忘了这一步,程序就只盯着上一次就绪的那几个,其他连接永远等不到响应。
三、poll
poll 是 System V 时代引入的,后来 Linux 也跟进了。
它换了一个数据结构:不用位图,改用 pollfd 数组。每个元素里填 fd 和关心的事件,返回时 Revents 字段告诉你发生了什么。
css
fds := make([]unix.PollFd, 0)
fds = append(fds, unix.PollFd{Fd: listenFd, Events: unix.POLLIN})
for _, fd := range conns {
fds = append(fds, unix.PollFd{Fd: int32(fd), Events: unix.POLLIN})
}
n, _ := unix.Poll(fds, -1)
for i := 0; i < len(fds) && n > 0; i++ {
if fds[i].Revents&unix.POLLIN != 0 {
n--
// 处理这个 fd
}
}
这解决了 FD_SETSIZE 的问题。fd 数量不再被一个编译时常量卡死,理论上你可以传一个很大的数组进去,只要系统允许打开那么多 fd。
但 poll 没有解决根本问题。每次调用,你仍然要把整个数组从用户态拷到内核态,内核仍然要线性遍历每一个元素。开销依旧是 O(总连接数)。
poll 只是让"一万个连接"这件事从"不可能"变成了"可能但很慢"。
四、epoll
Linux 2.5 时代,epoll 出现了。
思路完全变了。
你不需要每次调用都递一份全量名单。分三步走:
epoll_create创建一个内核里的 epoll 实例。epoll_ctl把关心的 fd 注册进去,告诉内核"这个 fd 我盯着读"。注册一次就行。- 之后反复调用
epoll_wait等事件。内核返回的,只有就绪的那几个 fd。
css
epfd, _ := unix.EpollCreate1(0)
// 注册 listen_fd,只注册一次
unix.EpollCtl(epfd, unix.EPOLL_CTL_ADD, listenFd,
&unix.EpollEvent{Events: unix.EPOLLIN, Fd: int32(listenFd)})
events := make([]unix.EpollEvent, 128)
for {
// 只返回就绪的 fd,不遍历注册表
n, _ := unix.EpollWait(epfd, events, -1)
for i := 0; i < n; i++ {
fd := int(events[i].Fd)
// 处理这个 fd
}
}
为什么快?因为内核在 epoll 实例里维护了两样东西:
- 一个红黑树,存所有注册的 fd,方便增删查。
- 一个就绪队列,存当前有事件的 fd。
当网卡收到数据、协议栈处理完、发现某个 socket 的接收缓冲区有内容了,内核通过回调把对应的节点从红黑树里"拎"出来,挂到就绪队列上。
epoll_wait 做的事情极其简单:看就绪队列空不空,不空就把里面的东西拷贝给你。它不遍历红黑树,不关心你注册了一万个还是十万个 fd,只关心有几个是活的。
所以开销从 select/poll 的 O(总连接数) 变成了 O(活跃连接数) 。对于典型的 Web 服务------大量连接静默、少量连接活跃------这是数量级的差异。
不过有一点要说明:epoll 不是在所有场景下都更快。如果你的服务总共就几十个连接,或者所有连接都在疯狂收发数据,epoll 的红黑树和回调机制反而带来额外开销。epoll 的优势,只在"N 很大且活跃比例很低"时才真正兑现。
五、LT 和 ET
epoll 比 select/poll 多了一个需要程序员自己做决定的东西:触发模式。
水平触发(LT)是默认的。 只要 fd 的缓冲区里还有数据,epoll_wait 就会一直通知你。语义上跟 poll 一样,写起来最安全------这次没读完的话,下次还会提醒。
边缘触发(ET)只在状态变化时通知一次。 man page 里有一个经典例子:写端往管道里写了 2KB,你收到通知,但只读了 1KB。如果你用的是 ET 模式,下一次 epoll_wait 可能永远挂起。因为剩下的 1KB 不构成"新事件"------状态没有发生新的变化,内核不会再次通知你。写端在等你的响应,你在等一个永远不会来的事件。死锁就这么发生了。
所以 man page 对 ET 模式给了硬性要求:必须用非阻塞 fd,并且必须在收到事件后循环 read,直到返回 EAGAIN。
go
func handleET(fd int) {
buf := make([]byte, 4096)
for {
r, err := unix.Read(fd, buf)
if r > 0 {
process(buf[:r])
} else if r == 0 {
unix.Close(fd)
return
} else {
if err == unix.EAGAIN || err == unix.EWOULDBLOCK {
return // 缓冲区真空了,可以安全地回去 EpollWait
}
unix.Close(fd)
return
}
}
}
读到 EAGAIN 了,才说明内核缓冲区真的空了。
这时候再去等下一次 epoll_wait,才是安全的。
这是 ET 模式最容易写错的地方。很多"请求偶尔卡住、延迟莫名其妙飘高"的线上 bug,根因就是 ET 模式下读了一次就跑了。剩下那点数据卡在内核里,等到下一个新数据包到达才触发事件。排查的时候看监控指标一切正常,CPU 不高、内存不高、连接数不高,但就是有万分之几的请求超时。这种问题比限流阈值配错了难查十倍。
六、EPOLLONESHOT
如果你的服务有多个工作线程同时在 epoll_wait 上等,一个 fd 就绪时,可能唤醒多个线程。如果两个线程同时去读同一个 socket,数据顺序就乱了。
EPOLLONESHOT 解决这个问题。注册 fd 时加上这个标志,一个事件被某个线程取走之后,这个 fd 在 epoll 实例里就被暂时禁用了 。处理线程做完自己的事,必须显式用 EPOLL_CTL_MOD 重新"武装"它,下一个事件才会被递送。
php
unix.EpollCtl(epfd, unix.EPOLL_CTL_ADD, cfd,
&unix.EpollEvent{Events: unix.EPOLLIN | unix.EPOLLONESHOT, Fd: int32(cfd)})
// 处理完后重新武装
unix.EpollCtl(epfd, unix.EPOLL_CTL_MOD, cfd,
&unix.EpollEvent{Events: unix.EPOLLIN | unix.EPOLLONESHOT, Fd: int32(cfd)})
这样能保证同一时刻只有一个线程在碰这个连接。
还有一个细节:如果读写都要关注,可以在 EPOLL_CTL_ADD 时一次性注册 EPOLLIN | EPOLLOUT,避免后面反复用 EPOLL_CTL_MOD 在两者之间切换。
七、Go 语言的情况
前面写的都是直接调 unix 包。日常写 Go 代码,用的是 net 包。
css
ln, _ := net.Listen("tcp", ":8080")
for {
conn, _ := ln.Accept()
go handleConn(conn)
}
看起来是一连接一 goroutine。但 goroutine 不等于线程。
conn.Read 在底层是非阻塞 fd 上的 read,返回 EAGAIN 时,Go 运行时把当前 goroutine 挂起,把系统线程让给其他 goroutine。
一个 OS 线程可以调度成千上万个 goroutine。
Go 运行时在 Linux 上,自己就用一个 epoll 实例管理所有网络 fd:
net.Listen返回的 fd 是非阻塞的,注册到运行时的 epoll 实例。conn.Read返回EAGAIN时,运行时把 goroutine 挂到该 fd 的等待队列上。- epoll 通知某个 fd 就绪时,运行时唤醒挂在它等待队列上的 goroutine。
EPOLLONESHOT、LT/ET 这些细节,运行时都替你处理了。
Go 网络服务能扛十万连接,靠两样东西:goroutine 本身足够轻,以及运行时用 epoll 把这些 goroutine 调度起来。 但代价是触发模式由运行时统一决定,没法针对单个 fd 做 EPOLLONESHOT 级别的控制。需要这些控制时,只能绕过 net 包直接调 unix.Epoll*。
八、回到服务治理
限流、熔断、降级这些治理手段,作用在请求层面。但请求能不能被高效地接住,首先取决于 IO 层。
一个用阻塞 IO 写的服务,流量高峰时的第一反应是线程数暴增。线程一多,上下文切换开销上去,每个请求的处理时间都变长,超时开始出现。这时候你上熔断策略,确实能挡住一部分流量,但根上的问题是:你的资源花在了"等待"上,而不是"处理"上。
多路复用把等待的成本压到了极低,线程池才真正被用来执行业务逻辑,限流和熔断的阈值也才有稳定的基准可言。
而 ET 模式写错了产生的延迟毛刺(指绝大多数请求的延迟都正常,但偶尔有极少数请求的延迟突然飙高,形成一个短暂的"尖刺",然后很快又恢复正常),如果被误判为"治理策略不够激进",你可能会去调限流阈值、加机器、上更复杂的熔断规则,但问题根本不在那一层。
九、最后总结
select 的问题是 API 层面的 :每次调用传全量集合,O(N) 的遍历成本绕不过去,FD_SETSIZE 还卡死了上限。
poll 去掉了上限,但没改本质。每次还是全量拷贝、线性遍历。
epoll 把注册和等待拆开 ,epoll_wait 只看就绪队列,在大量空闲连接的场景下把内核开销从 O(总连接数) 压到了 O(活跃连接数)。但代价是:你得自己管好 epoll_ctl 的生命周期,得搞明白 LT 和 ET 的语义差异,ET 模式下还得写正确的 EAGAIN 循环。
Go 的 net 包把这些全封装了。写 go handleConn(conn) 就能享受 epoll 的好处。但理解底层机制,才能在出问题时知道该看哪一层:goroutine 泄漏、fd 耗尽,还是绕过了运行时直接调 unix.Read 忘了处理 EAGAIN。
写对了,它是十万连接的底座。写错了,它制造出的延迟毛刺比 select 时代更难排查。
学习资料
man page(最权威,建议直接读)
man 7 epoll:LT/ET 的语义、EPOLLONESHOT的用法、2KB 管道的例子,都出自这里。在线版:man7.org/linux/man-p...man 2 select:man7.org/linux/man-p...(FD_SETSIZE行为、返回后集合被修改)man 2 poll:man7.org/linux/man-p...(pollfd结构、revents语义)man 2 epoll_wait:man7.org/linux/man-p...(参数、返回值、maxevents约束)
Michael Kerrisk 的 epoll 讲义
man7.org 作者本人的 slides,把 interest list、ready list、边缘触发细节拆得很清楚。PDF 直接下载:kerrisk.com/training/do...
Go 相关
net包文档:pkg.go.dev/net- 运行时 netpoller 源码:golang.google.cn/src/runtime...
- Linux 平台 epoll 实现:go.googlesource.com/go/+/refs/h...
书
- 《深入理解 Linux 网络》第 3 章:epoll 内核对象的创建、添加 socket、
epoll_wait等待、数据到达后的回调,源码级拆解。 - 《高性能 Linux 网络编程核心技术揭秘》:有基于 epoll 的高并发服务器实战章节。