在 05 篇里,我们用了上、中、下三篇文章,梳理清楚了 Kafka 中 Acceptor、Processor 和 Handler 线程各自的职责,以及它们之间的配合方式。与此同时,我们也反复提到:Kafka 没有使用 Netty,而是自己实现了一套 NIO。
但前面那三篇并没有真正展开 Kafka 的 NIO 究竟是怎么运作的。所以,从接下来的几篇开始,我想专门讨论那些此前频繁出现、却始终没有细讲的关键词——register、interestOps、selectedKeys、wakeup,以及我们抓到的 acceptor 线程栈最底下那几行:
at sun.nio.ch.EPoll.wait(...)
at sun.nio.ch.EPollSelectorImpl.doSelect(...)
at sun.nio.ch.SelectorImpl.lockAndDoSelect(...)
at sun.nio.ch.SelectorImpl.select(...)
当时我只知道:「它在等新连接」。但这四行到底完成了什么工作,并没有继续往下追。后来回头再看,才发现这里其实不是 Kafka 自己的“黑魔法”,而是 Java NIO 的地基在起作用。Kafka 的 Selector、KafkaChannel、TransportLayer,底层都建立在 java.nio 之上。要真正看懂 Kafka 的网络层,就必须先把 Java NIO 自身搞明白。
因此,这一篇先不碰 Kafka 源码,而是从 JDK 和一个自己动手实现的 echo 服务讲起。把这些看清楚之后,再回头看上面那几行堆栈,EPoll.wait 就不再只是一个名字,而会变成一个可以落到具体动作上的概念。
- 一个线程一条连接的 BIO,为什么撑不住万级连接?C10K 到底卡在哪一步?
Buffer/Channel/Selector三件套,凭什么能让一个线程看住几千条连接?select/poll/epoll差在哪里,落到 JDK 侧又是什么?- Reactor 的三种形态怎么区分,Kafka 的 Acceptor / Processor 属于哪一种?
- JDK 21 的虚拟线程让「一连接一线程」重新成立,它和 NIO、和 Go 的 netpoller 是什么关系?
为什么 BIO 撑不住 C10K
所有网络服务的故事,通常都从 ServerSocket 这个阻塞的 accept 开始。BIO(Blocking I/O)模型里,服务端主循环一般长这样:
while (true) {
Socket socket = server.accept(); // 阻塞点一:没有新连接就停在这里
Thread t = new Thread(() -> serve(socket));
t.start();
}
accept 会阻塞:没有新连接就停在那里;连上之后交给一个新线程,serve 里面的 read 又会继续阻塞,没数据到来就继续停住。两个阻塞点,把一条线程从头到尾钉死在一条连接上。这段逻辑,就是 examples/06/BioEchoServer.java 的第 27–36 行的核心骨架(这里简化了一点,省掉了线程计数和 setDaemon 那几行),后面的上机实验里,我们会看到它真实跑起来是什么样子。
那为什么说这种模型撑不住万级连接?主要有三笔账。
第一笔是内存账。每条线程都有自己的栈,默认 -Xss 在 1MB 量级(HotSpot 64 位默认大约 1MB,具体也可通过 JVM 参数调整)。一万条连接就是一万条线程,光线程栈就约等于 10GB 地址空间。即使物理内存勉强扛得住,线程对象本身的调度开销也早已把系统压垮。
第二笔是上下文切换账。操作系统调度器会按「可运行线程数」分配 CPU 时间片,线程越多,每条线程两次被调度之间的间隔就越长,而切换本身也要吃 CPU。连接数是 N,调度开销大致就会随 N 一起增长;等 N 上万之后,CPU 花在「换线程」上的时间,很可能比花在「真正干活」上的时间还多。
第三笔是利用率账。大多数线程大部分时间都堵在 read 上——真正执行请求处理的时间,也许只占它生命周期的百分之一。为了那一点点计算,以及一段可能几毫秒才来一次的数据,长期养着一条线程,性价比低得惊人。
三笔账合在一起,就是经典的 C10K 问题:单机如何同时处理上万连接。BIO 的答案是「一线程一连接」,于是线程数被迫和连接数线性绑定——而这恰恰是它扩展性的根本死穴。
最常见的一种「改良」是线程池:比如 Executors.newFixedThreadPool(200),用来顶住突发连接,避免 accept 无限开线程。但线程池只是改变了线程的生命周期——线程可以复用——却没有改变「线程和连接绑定」的基本关系。200 个线程最多同时服务 200 条连接,第 201 条连接不是排队,就是等前面某条连接处理完。连接数一旦长期高于线程数,线程池就只是一块遮羞布:它把「线程爆炸」换成了「连接排队」,模型本身并没有变。
线程池是 2004 年左右的答案,而这笔账真正有了新还法,要等到 2023 年 JDK 21 中虚拟线程(JEP 444,Project Loom)正式转正。
它首先正面解决的是第一笔内存账:平台线程的栈按 -Xss 整块预留,通常接近 1MB;而虚拟线程的栈放在堆上、按需增长,空载开销只有几百字节,百万线程不再是天文数字。调度也换了主体:不再由内核直接按线程表调度,而是 JVM 自己把大量虚拟线程复用到少量载体线程(carrier thread)上,数量大致等于 CPU 核数。挂起和恢复也主要发生在用户态,因此第二笔上下文切换账也被显著打折。
它首先正面解决的是第一笔内存账:平台线程的栈按 -Xss 整块预留,通常接近 1MB;而虚拟线程的栈放在堆上、按需增长,空载开销只有几百字节,百万线程不再是天文数字。调度也换了主体:不再由内核直接按线程表调度,而是 JVM 自己把大量虚拟线程复用到少量载体线程(carrier thread)上,数量大致等于 CPU 核数。挂起和恢复也主要发生在用户态,因此第二笔上下文切换账也被显著打折。
于是「一连接一线程」就重新成立了:把 new Thread(...) 换成 Thread.ofVirtual().start(...),看起来只是一行代码的改动,800 条连接就可以对应 800 条虚拟线程。第三笔利用率账也跟着一起松动——后面上机部分的 ⑤ 变体,测的就是这个。
但先别急着宣判 NIO 过时。这里有两件事必须想清楚。
第一是版本账。虚拟线程要到 JDK 21 才正式可用,而 Kafka 4.3.1 的基线仍是 non-client 17,clients 模块甚至还在 11。也就是说,Kafka 这套网络层的设计,发生在 Loom 立项(2017 年前后)前很多年,压根没有虚拟线程这个选项。后文之所以选 JDK 17 来对照 EPollSelectorImpl,也正是这个原因。
第二是原理账。虚拟线程并没有绕开「就绪事件模型」,它只是把这部分复杂度从程序员手里搬进了 JVM 内部。虚拟线程在 read 上「阻塞」时,JVM 会先把它挂起,再把对应 fd 交给内部的 Poller 线程(sun/nio/ch/Poller.java)。在 JDK 25 的源码树里核对可以看到:macOS 上用的是 KQueuePoller,Linux 上则是同样基于 epoll 的 EPollPoller。它和后面要看的 EPollSelectorImpl 一样,都是平台相关实现。等 fd 就绪之后,JVM 再把这条虚拟线程唤醒回来继续执行。
这个证据在 SocketChannelImpl 里就能找到:blockingRead 为虚拟线程加了一条 configureSocketNonBlockingIfVirtualThread 分支——先切到非阻塞试读,读不到就交给 Poller 挂起。换句话说,epoll_wait 一次都没有少,只是它不再出现在你的业务线程栈底,而是挪进了 JVM 自己的线程栈底。
所以,这篇要讲的地基并不会因为虚拟线程而过时。恰恰相反:虚拟线程越成功,越说明 Selector / epoll 这一层地基讲得有必要——它们只是从「你来直接使用」变成了「JVM 替你使用」。
要跳出 BIO 的根本路子,归根结底只有一条:让一个线程同时「看住」多条连接,只有当某条连接真的可读、可写时,才去处理它——要么由你自己来做(NIO),要么交给运行时(JVM 的 Poller,或者后面提到的 Go 运行时)。
问题随之而来:线程怎么知道「哪条连接就绪了」?总不能对每条连接挨个 read 试一遍——那又绕回了阻塞。这个问题,正是 Selector 要回答的;而 Selector 的答案,又离不开 Channel 和 Buffer 这两个搭子。三件套必须放在一起讲。
在正式展开三件套之前,不妨先站远一点,看看别的语言是怎么回答同一个问题的。
写 Go 的人读到这里,多半会想起 select。但它和 Java 的 Selector 不在同一层:Go 的 select 是语言关键字,等的是一组 channel 操作,由运行时调度器兑现;真正对应 Selector 角色的,是 Go 运行时里的 netpoller。goroutine 调 conn.Read,写法看起来是阻塞的,实际上是运行时把 goroutine 挂起,再把 fd 交给 epoll/kqueue,就绪后再调度回来。程序员从头到尾看不到“就绪事件”本身。
Python 的 asyncio 则像第三条路:就绪模型摆在明面上,selectors 模块同样封装 epoll/kqueue,但它用 async / await 把回调链藏进了协程语法。
三家摆在一起很有意思:内核地基都一样,差别只在于“谁替你看 fd”。
- Java NIO:你自己看;
- Go:运行时全替你看;
- Python asyncio:中间路线。
Java 一直到虚拟线程,才把这一层补上;前面提到的 Poller,本质上就是 JVM 版的 netpoller。这个对照如果真展开,JVM、Go Runtime、CPython 各自怎么挂起、怎么唤醒、怎么调度,其实都够单独写几篇番外了。这里先记个坐标,正文继续回到 Java NIO。
Buffer:把「读写一块内存」变成显式状态机
先说最容易被低估的东西:Buffer。
用惯了 InputStream.read(byte[]) 的人,第一次看 ByteBuffer 往往会有点困惑:为什么只是读写同一块内存,还要手动在「写模式」和「读模式」之间切换?
答案在于,ByteBuffer 内部维护了三个关键指针——capacity、position、limit。和 InputStream 那种「读一点就丢一点」的简单模型不同,ByteBuffer 把「这块内存现在处在什么阶段」这件事,变成了程序员显式维护的状态机。
capacity:缓冲区总容量,创建后不再变化;position:下一个要被读或写的位置;limit:读写操作的上界。写模式下表示「最多能写到哪」,读模式下表示「最多能读到哪」。
三者之间的关系,决定了缓冲区当前到底是在「读」还是在「写」。而切换模式,靠的就是那几个第一次读代码时总记不住的方法。回到 JDK 源码里看,它们的实现其实很直白(java/nio/Buffer.java,JDK 17):
// flip():*Buffer.java:472-477*
// 把 limit 设为当前 position,position 归零——从「写满了」切成「可以读了」
limit = position;
position = 0;
mark = -1;
// clear():*Buffer.java:444-449*
// position 归零、limit 拉满——整个缓冲区重新可写
position = 0;
limit = capacity;
mark = -1;
flip() 表示「写完了,现在开始读」,clear() 表示「读完了,从头再写」。但真实世界里还不止这两种状态。更常见的第三种情况是:读了一半,还没读完;这时不能直接 clear(),因为后半段数据还要保留。你得先把已经读过的部分丢掉,再把剩下没读完的数据挪到头部,给后续继续写留出空间——这就是 compact() 的作用。
在 java/nio/ByteBuffer.java 的 javadoc 里,compact() 的定义就是把 [position, limit) 这段残留字节拷回头部,并把 position 设置为剩余字节数。它的存在理由,javadoc 甚至直接给了一个反复出现的范例:
buf.flip(); // 切成读模式
out.write(buf);
buf.compact(); // 若只发出去一部分,把没发的挪到头部,继续下次
为什么要这么麻烦?因为网络 I/O 的本质,就是「部分完成」。
read可能只读到半个请求;write也可能只发出去一半。
InputStream 用内部游标替你处理了这些细节,代价是你对「还剩多少没处理、下次该从哪继续」几乎没有控制权。ByteBuffer 则把控制权交还给了你。那三个指针,本质上就是一本「读写进度账」;而 flip / compact / clear 就是翻账本的动作。
到了 07 篇你会看到,Kafka 的 NetworkReceive 正是靠这套机制,把「半包」慢慢攒成「整帧」。

这里还有一个实现层面的分叉,需要我们关注。
ByteBuffer.allocate(n) 创建的是 HeapByteBuffer,底层是 JVM 堆里的 byte[];而 ByteBuffer.allocateDirect(n) 创建的是 DirectByteBuffer,底层是堆外的 native 内存。
两者差别很关键:
- 堆内缓冲区分配和访问都更轻便,但每次交给系统调用
read/write时,通常还要多经历一次拷贝; - 堆外缓冲区可以省掉这次拷贝,但分配和回收更贵,也不受 GC 直接管理。
这条分叉,是后面讲 Zero Copy 与 sendfile 时的重要伏笔。先记住一句话就够了:
Buffer 显式管理的,不只是读写进度,还卡着一条「内存放哪」的性能分界线。
Channel:双向、可非阻塞的传输口
Buffer 是数据容器,Channel 则是数据进出的管道。相对于传统的 Stream,Channel 有两个关键区别。
第一,它是双向的。
InputStream 和 OutputStream 是两条单向通道,读一个 socket 往往要拿两个流对象;而 Channel 本身是双向的,SocketChannel 既能 read,也能 write。
这不只是「省一个对象」这么简单。05 篇里 Kafka 的同一条连接既要收请求,也要发响应,复用同一个 TransportLayer,底层依赖的正是 Channel 这种天然双向的模型。
第二,它可以切到非阻塞模式。
这才是整个 NIO 真正的转折点。ServerSocketChannel / SocketChannel 都可以通过 configureBlocking(false) 切到非阻塞模式。切过去之后:
int n = channel.read(buffer);
read 不再是「等到有数据才返回」,而变成「有多少读多少;如果一个字节都没有,就立刻返回 0」。
JDK 里 SocketChannelImpl.read 的非阻塞分支(sun/nio/ch/SocketChannelImpl.java)就是这么实现的:非阻塞模式下,只调一次底层 IOUtil.read,拿到 n 就立刻返回;只有阻塞模式下,它才会循环 park 重试,直到真的读到数据或者结束。读到流末尾(EOF)时则返回 -1——这也是后面实验里 Conn.readAndEcho 用来判断对端关闭连接的依据。
还有一条更彻底的路子值得一提:AsynchronousSocketChannel(AIO)。它把「读完了叫我」这件事交给内核回调,代码写起来甚至更接近同步。但在 Linux 上,它很大程度依赖内部线程池来兜底,生态和可观测性都偏弱,最终没有成为 Java 高并发网络编程的主流。真正站稳脚跟的,还是「非阻塞 + 就绪事件」这条线。
而非阻塞的意义就在于:既然 read 不再替线程等待数据,那线程就必须从别处得知「这条连接现在可读了」。那个「别处」,就是 Selector。
Selector:一个线程看住一批连接
Selector 是 NIO 三件套里最反直觉、也最核心的部分。它的使用方式,可以概括成四步(JDK 类注释把这一过程直接叫作「Selection」):
- 把通道注册到
Selector上,并声明「我关心哪类事件」,通过interestOps表达——OP_ACCEPT(新连接)、OP_READ(可读)、OP_WRITE(可写)、OP_CONNECT(连接建立完成); - 调用
select()——阻塞在这里,直到至少一个已注册通道发生了你关心的事件; - 从
selectedKeys()取出本轮就绪的 key,逐个处理; - 处理完后,把 key 从 selected 集合里移除。这个动作必须手动做,否则下次 select 还会看到它——这是 NIO 新手最容易踩的坑之一。
examples/06/NioEchoServer.java 的主循环就是这个骨架。为了突出调度逻辑,我把处理细节折成了注释:
while (true) {
selector.select(); // 阻塞在这,直到至少一个通道就绪
Set<SelectionKey> selected = selector.selectedKeys();
Iterator<SelectionKey> it = selected.iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
it.remove(); // 必须手动移除,否则下次还在集合里
if (key.isAcceptable()) { /* accept 新连接,register(OP_READ) */ }
else if (key.isReadable()) { /* 读、成帧、回显 */ }
else if (key.isWritable()) { /* 发还没发完的数据 */ }
}
}
一个线程,一个 while 循环,就能看住几千条连接。BIO 里的两个阻塞点,在这里都被改写了:
select统一替线程「等数据」;configureBlocking(false)让真正的读写操作在没事时快速返回,而不是把线程钉死。
这就是所谓的就绪事件模型。
Selector 内部大致维护三组集合:
- key set:所有已注册的 key;
- selected-key set:本轮已就绪的 key;
- cancelled-key set:调用了
cancel()、但还没真正注销的 key。
select() 干的事,本质上就是把「已就绪」的 key 从第一组挪进第二组。至于「就绪」怎么判断,可以看底层实现 sun/nio/ch/SelectorImpl.java 的 processReadyEvents:只要 nioReadyOps & nioInterestOps != 0,也就是「实际就绪事件」和「你声明关心的事件」有交集,这个 key 就会进入 selected 集合。
这里还藏着一个很重要的性质:select 是水平触发(level-triggered)的。只要某条连接的读缓冲里还有没被读走的数据,下一次 select 依然会把它报告为可读。所以「就绪」不是一次性通知,而是一种会被持续报告的状态。
这既是它比边缘触发更省心的地方,也解释了为什么很多场景下,处理完之后还要主动调整 interestOps:如果不控制好兴趣集,select 可能会一直把同一条连接报回来,导致空转。
这里必须先建立一个核心认知:
就绪,不等于有一条完整消息可读。
OP_READ 就绪,只意味着「此刻这条连接上有字节可读」。它可能是半条消息,也可能只有几个字节。SelectionKey 的类注释写得很克制:就绪集合「is a hint, but not a guarantee」——它只是一个提示,不是完整消息的保证。
所以应用层不能把「可读」误解成「可以一次性读出一整条消息」。它必须像 Conn.readAndEcho 那样:读到多少算多少,用 ByteBuffer 先攒着,只有凑够完整一帧时才真正处理;如果还是半包,就得像 in.position(start) 那样把位置退回,等下一批字节继续补齐。
「就绪事件 + 应用层自己累积成帧」,这是所有基于 NIO 的协议栈共同的起点,Kafka 也不例外。
另一个很容易被忽略、但在实战里极其关键的机关是 wakeup()。
select() 是阻塞在一个线程里的,但你经常会需要从别的线程把它叫醒——比如有新连接要交给它、或者服务要停了。Selector.wakeup() 就是干这个的:
- 如果
select正在阻塞,它会让select立刻返回; - 如果
select此刻没在阻塞,它会让下一次select立即返回一次。
05 篇中篇里,Processor 周围那个反复出现的 wakeup()——Acceptor 派发新连接后叫醒 Processor、Handler 把响应放进队列后叫醒 Processor——调用的其实就是这个 JDK 方法。Kafka 只是包了一层再转发(clients/src/main/java/org/apache/kafka/common/network/Selector.java:361-362 里就一行:this.nioSelector.wakeup())。到这里,这条跨线程唤醒的线终于和 05 篇接上了。
顺带也把一个并发边界说清楚。Kafka 自己那层 Selector 的类注释末尾明确写着:「This class is not thread safe!」(clients/src/main/java/org/apache/kafka/common/network/Selector.java:86)。但它内部包装的 JDK Selector 不是同样的待遇——JDK 文档里说,Selector 本身以及 key set 可以被多线程使用,真正不安全的是 selected-key set 和 cancelled-key set。
这两句话并不矛盾。JDK 的 Selector 在并发语义上做得更细,而 Kafka 在它之上叠加的那层状态——例如 KafkaChannel 表、缓冲区、连接状态等——并没有做线程安全封装。所以,05 篇下篇里那个「响应必须按 processor id 回投」的设计,就很好理解了:一条连接及其背后的 Selector 状态,只能由一个 Processor 独占,不能让别的线程随便碰。
select / poll / epoll:差在哪,落到 JDK 是什么
看到这里,你也许会以为 Selector 是某种「JDK 新魔法」。其实剥开之后,在 Linux 上它就是 epoll 的一层封装。而 epoll 相比更早的 select / poll,最根本的进步值得单独讲一节。
select 和 poll 的问题在于:每次调用都要全量搬运 fd 集合。
应用程序把「我关心的全部 n 个 fd」传给内核,内核逐个扫描,再返回哪些 fd 有事件。这样一来,n 越大,每次调用的拷贝和扫描成本就越接近 。你有一万条连接,即使其中只有一条真的有数据可读,每次也得把一万条全扫一遍。
epoll 换了个思路:把「注册」和「等待」拆开。
epoll_ctl:把关心的 fd 登记进内核,只做一次;内核内部为这个 fd 维护就绪关系;epoll_wait:真正等待时,只取回「已经就绪」的那批 fd。
因此,连接总数再大,只要活跃连接比例不高,epoll_wait 的成本就基本和「总连接数」脱钩,而更接近「本轮就绪了多少个 fd」。这就是 NIO 能扛住 C10K 的内核基础。
落到 JDK 这一层,Selector 是一个抽象接口,不同平台会落到不同实现上:
- Linux:
sun.nio.ch.EPollSelectorImpl; - macOS:
KQueueSelectorImpl(BSD 的kqueue); - Windows:另一套实现。
注意,EPollSelectorImpl 是 Linux 专属的。
为了和 05 篇里那条 Linux 栈对上,这里后面统一以 JDK 17 的 EPollSelectorImpl 为准来讲(选 17 的原因也很实际:它正好是 Kafka 4.3.1 对 non-client 模块要求的最低版本,而 clients 模块则还是 11)。
它的 doSelect(sun/nio/ch/EPollSelectorImpl.java)把我们前面说的那些抽象概念,落成了几个很具体的动作:
// doSelect 的主干(EPollSelectorImpl.java,简化)
processUpdateQueue(); // 先把 register/改 interestOps 攒下的变更,用 epoll_ctl 落进内核
processDeregisterQueue(); // 注销已 cancel 的 key
begin(blocking);
do {
// 核心:一次 epoll_wait,取回就绪事件(最多 NUM_EPOLLEVENTS 个)
EPoll.wait(epfd, pollArrayAddress, NUM_EPOLLEVENTS, to);
} while (/* 条件 */);
end(blocking);
processEvents(); // 把就绪事件翻译成 selectedKeys
这里有三个细节,正好把这一节和 05 篇真正接起来。
NUM_EPOLLEVENTS:就绪事件是分批取回的
NUM_EPOLLEVENTS 表示一次 epoll_wait 最多取回多少个事件,它的值是 Math.min(IOUtil.fdLimit(), 1024),也就是 fd 上限和 1024 之间取较小值。
为什么要有这个上限?因为 epoll_wait 会把结果填进一块固定大小的 native 内存 pollArray,容量必须预先定死。这也意味着,「就绪集合」不是无限大的一次性结果,而是分批取回的。
processUpdateQueue:register/interestOps并不会立刻通知内核
这是我第一次读 NIO 时最困惑的地方之一:register() 和 interestOps() 看起来只是普通方法调用,那它们到底什么时候真正通知内核?
答案是:并不会立刻通知。
processUpdateQueue 告诉我们,JDK 会先把这些变更攒进 updateKeys 队列,等到下一次 doSelect 开头时,再统一通过 epoll_ctl 去做 EPOLL_CTL_ADD / MOD / DEL。
这也解释了为什么 05 篇里很多「改完 interestOps」的地方,旁边往往紧跟着一个 wakeup():因为如果不把阻塞在 epoll_wait 里的线程叫醒,它根本没有机会回过头来处理你刚刚提交的变更。
wakeup():本质上是让一个特殊 fd 变可读
这一点最有意思。EPollSelectorImpl 里的 wakeup 不是「发个信号」这么抽象的东西,而是往一个 eventfd 写入一个数。eventfd 是 Linux 提供的一种事件通知 fd。
更妙的是,在 EPollSelectorImpl 构造时,这个 eventfd 就已经通过 epoll_ctl 注册进 epfd 里了。于是,所谓「唤醒 Selector」,本质上就变成了:
让这个内部自带的 eventfd 变成可读。
这样一来,下一次 epoll_wait 自然就会返回;随后 processEvents 发现本轮就绪的其实是这个 eventfd,于是把它识别成「被唤醒」,再把计数清掉。
用一个内部注册的特殊 fd,把「跨线程打断」统一进了「等待 fd 就绪」这个模型里。
这一手非常漂亮——系统里从头到尾就只有一套事件等待机制,没有额外再造一套线程间通知通道。
版本提示:本篇之所以统一标 JDK 17,是因为它和 Kafka 4.3.1 的版本基线对得上。我又用 JDK 25 的源码树核对过:
EPollSelectorImpl/KQueueSelectorImpl依然是 Linux / macOS 的默认Selector实现,doSelect还在。随虚拟线程进入 JDK 的Poller/EPollPoller,则是另一套专供虚拟线程使用的基建,并不会替代Selector。
Reactor 三种形态:Kafka 站在哪一种
把前面几样东西拼起来,就是大名鼎鼎的 Reactor 模式:一个或多个线程用 Selector 监听一批连接,事件到了之后,再分发给对应的处理逻辑。
如果按「谁负责 accept、读写被分到几条线程」来划分,常见的 Reactor 形态大致有三种。
单 Reactor 单线程
一个线程、一个 Selector,accept、read、write 全都在同一个循环里处理。上面 NioEchoServer.java 的例子,就是这个最朴素的形态。
它最大的优点是简单:没有线程间交互,天然也就少锁、少切换。但它成立的前提是——每个请求处理都必须足够快。只要某个请求处理稍微慢一点,它不仅会拖住别的连接,也会拖住新连接的接入。
Redis 5.x 及更早版本,就是这个极端形态的典型代表:命令处理是纯内存操作,微秒级完成,「处理」本身几乎不构成瓶颈,所以一个线程足够。
单 Reactor 多线程
Reactor 线程只负责 accept 和读写事件分发,把真正耗时的「业务处理」甩给一个 worker 线程池。
这样一来,慢处理就不会直接堵住事件循环。代价是,引入了跨线程协作:worker 处理完之后,还得把结果交回 Reactor 线程去写回 socket,因为那条连接及其 Selector 仍然归 Reactor 线程独占。这一来一回,就会用到前面提到的 wakeup()。
主从 Reactor(多 Reactor)
再往前走一步,把「接收新连接」本身也独立出来:Main Reactor 专门负责 accept,新连接进来后轮询分发给一组 Sub Reactor;每个 Sub Reactor 各自持有一个 Selector,各管一批连接的读写。
当连接建立本身就可能成为瓶颈时——比如海量短连接,或者 accept 与新连接注册竞争同一条线程——把 accept 单独拎出去就很自然了。
现在回头看 Kafka,位置就非常明确了:
Kafka 用的就是主从 Reactor,而且是「裸 NIO 手工版」。
05 篇上篇中的 Acceptor,就是 Main Reactor:只负责 accept,然后把新连接轮询派发给 Processor。05 篇中篇中的 Processor,就是 Sub Reactor:每个 Processor 独占一个 Selector,各自管理一批连接的读写。
如果把 examples/06/MasterSlaveEchoServer.java 和 Kafka 的 SocketServer 并排看,结构几乎是一一对应的:
| 主从 Reactor 元件 | examples/06 骨架 | Kafka 对应(05 三篇) |
|---|---|---|
Main Reactor:只 accept | main() 独占 acceptor Selector(MasterSlaveEchoServer.java:113-136) | Acceptor(SocketServer.scala) |
| 新连接派发 | processors[idx].assign(channel) 轮询(:132-133) | Acceptor#assignNewConnection 选 Processor → Processor.accept 入 newConnections(SocketServer.scala:709、:1144) |
| Sub Reactor:各管一批连接 | 每个 Processor 独占一个 Selector + 线程(:22-33) | 每个 Processor(SocketServer.scala) |
| 跨线程唤醒 | assign() 里 selector.wakeup()(:37) | 派发/响应后 wakeup() |
Kafka 的 Acceptor 数量是「每个 listener 一个」,而 Processor 的数量正对应 num.network.threads。换句话说:
num.network.threads 的本质,就是「起多少个 Sub Reactor,每个各管一批连接」。
这是这一篇 NIO 原理对运维最直接的一次翻译:它不是「多开几条帮忙读字节的线程」那么简单,而是在决定「连接被分成几摊、每摊由一个独占 Selector 的 Reactor 来看」。
上机:echo 服务的四步演进
原理讲完,最好自己写一遍才算真正吃透。examples/06/ 目录里放的,就是同一个 echo 服务的四步演进;每一步都在同一套压测脚本下对比。此外,同目录还附了一个序列外的 ⑤ 变体——虚拟线程版,需要 JDK 21+,我本机用 JDK 25 跑通了,它正好用来验证前面关于 Loom 的两段判断。
这套实验不需要 Docker,本机就能直接跑:
① BioEchoServer → 一连接一线程(BIO)
② NioEchoServer → 单 Selector、单线程
③ ReactorEchoServer → 单 Reactor + worker 线程池
④ MasterSlaveEchoServer → Acceptor + 多 Processor(与 Kafka 同构)
⑤ VtEchoServer → ① 的一行改写:new Thread 换 Thread.ofVirtual()(序列外变体)
四个版本共用 examples/06/Conn.java,也就是每条连接上的读缓冲、写缓冲和成帧逻辑。差异只在于:线程如何摆放。
② ③ ④ 用的是同一套非阻塞读写内核,只是把 accept、读、写、业务处理分配到了不同线程组合上;
⑤ 不属于 Reactor 这条线:它的 serve 逻辑和 ① 几乎一字不差,仍然是阻塞读写,唯一真正变化的是建线程那三行——new Thread + setDaemon + start 换成了 Thread.ofVirtual().start(...)。虚拟线程天然就是 daemon,因此连 setDaemon 都一起省了。
它验证的就是前面那句话:「虚拟线程让『一连接一线程』重新成立」。
运行方式如下(examples/06/run-demo.sh,默认参数是 800 连接 × 200 消息 × 128B):
cd examples/06
./run-demo.sh
脚本会依次拉起四个服务加上 ⑤ 变体,用 jcmd Thread.print 抓一份服务端线程数,再用 EchoBench.java 压一轮,最后汇总结果。
我在本机(Intel i7,4 核 8 线程 / macOS)上的一轮实测数据如下。①–④ 使用的是 JDK 22.0.2,机器相对空闲;⑤ 的那轮见表下注释:
| 形态 | 服务线程数 | 结果 | 耗时 | 吞吐 | avg / p50 / p99 |
|---|---|---|---|---|---|
| ① BIO | ≈ 800 | 160000 / 0 | 6.3 s | 25300 msg/s | 26.6 / 25.9 / 118.6 ms |
| ② 单 Selector | ≈ 25 | 160000 / 0 | 6.8 s | 23500 msg/s | 29.9 / 27.9 / 62.3 ms |
| ③ Reactor(8) | ≈ 30 | 160000 / 0 | 8.1 s | 19900 msg/s | 36.0 / 33.3 / 90.4 ms |
| ④ 主从(3) | ≈ 30 | 160000 / 0 | 3.9 s | 41400 msg/s | 15.7 / 14.0 / 66.3 ms |
| ⑤ 虚拟线程 | ≈ 30(平台线程) | 160000 / 0 | 23.1 s | 6935 msg/s | 104.8 / 92.9 / 255.5 ms |
⑤ 这一行是后来单独测的:同一套脚本、同一台机器,先后在 JDK 22 和 JDK 25 下各跑过一轮,表里取的是 JDK 25 那轮。两轮机器都带着后台负载,所以绝对值整体偏低;例如 JDK 25 那轮里,同轮复测 ① 也只有约 6650 msg/s,而不是上表中的 25300。因此,⑤ 和 ① 的对比要以“同轮”结果为准;而 ①–④ 之间的横向比较,仍以原表为准。
先看最扎眼的一列:线程数。
BIO 用 800 条线程扛 800 条连接([BIO] totalConns=801 peakLiveThreads=800,多出来的 1 是脚本探活连接);而后面三个 NIO 版本,全都稳定在 25–30 条线程上下,直接少了一个数量级。这正好和前面那笔「线程数随连接数线性膨胀」的账严丝合缝地扣上了——这就是 NIO 存在的理由。
⑤ 虚拟线程最有意思的,也恰恰是这一列:peakLiveVThreads=800,说明一条虚拟线程对应一条连接,分毫不差;但 Thread.print 数出来的平台线程只有 30 条左右。原因也不神秘:虚拟线程住在堆上,默认线程转储并不会把它们完整展开,得用专门的 Thread.dump_to_file 才能看到全貌。BIO 撞上的那堵「本地线程数上限」墙,对虚拟线程来说基本不存在。
再看一个很诚实的事实:吞吐和延迟,并没有出现数量级上的差距。
原因也并不玄学:
- 测的是 loopback,本机回环网络几乎没有真实网络延迟;
- payload 只有 128B;
- 机器远没逼近真正的连接数上限。
在这种「和平」环境里,BIO 那 800 条线程虽然昂贵,但还没真正把系统压垮,NIO 的优势没有完全发挥出来。⑤ 也一样——它的读写逻辑依旧是阻塞式的,线程再便宜,也不会让回环小包凭空变快。同轮比较里,它和 ① 仍然属于一个量级:虚拟线程省的是线程账,不是 IO 账。
所以,NIO 真正的胜场不在这种本机微基准,而在「连接数继续上去时,谁先撞墙」。
把连接数继续拉到几千、上万,BIO 最先撞上的,是线程数和系统限制这堵墙。本机的 ulimit 与 per-user 进程上限大约在 2784 左右,再往上 accept 就会开始抛 OutOfMemoryError: unable to create native thread。而 NIO 这几种形态的线程数几乎不动;⑤ 虚拟线程也同样不会在这里先死,因为它不消耗对应数量的内核线程,连接数增长更多体现为堆里多了一批对象。这一条我这里是按内存账推出来的,还没实测到那个量级;想验证也不难,直接把脚本里的 CONNS 再往上调即可。
最后再说说表里那一行最亮眼的数据:为什么「④ 主从」明显比「③ Reactor」更快,也更稳定。
压测时我注意到一个反复出现的小噪声:Reactor 形态偶尔会掉几条连接,报 Broken pipe;而主从形态几乎总是 0 错误(上表这一轮恰好也是 0,掉线是在复跑几轮时才观察到的)。我怀疑根因和 macOS 的 kern.ipc.somaxconn 有关——listen backlog 的实际生效上限可能远小于应用层传入的 4096。几百条连接如果在同一瞬间涌来,而 accept 又稍慢,backlog 溢出就可能导致连接被重置。这个解释目前仍是推测,我没有把其他可能逐一证伪。
但即便不追究最终机理,现象本身已经足够说明问题:在 ③ 的单 Reactor 模式下,同一条线程既要 accept,又要处理已有连接的读写;新连接洪峰一来,只要它正忙,accept 就会慢半拍。而 ④ 的主从模式里,Acceptor 专职负责 accept,能第一时间把连接收进来,再派给 Processor。所以它的优势不一定只是「更快」,更重要的是:
它不容易让 accept 被既有连接的读写拖住。
这其实就是「为什么要把 Acceptor 单独拎出来」的一次很直观的现场演示。
对比参照:线程模型是「请求代价 + 部署形态」的函数
同样都是「一个线程看住一批连接」,为什么 Redis 可以长期用单 Reactor 单线程,Kafka 却要上多 Processor,Nginx 干脆走多进程?如果把「单次请求处理成本」和「部署形态」放到同一把尺子上,这几类系统会立刻排成一条光谱。
Redis 6.0 处在最左边:命令处理几乎是纯内存操作,微秒级,「等」基本不存在。所以它完全可以让事件循环线程自己直接执行命令,多 Reactor 反而成了浪费。它在 6.0 之后虽引入多线程,也主要只是把 read / write 这类系统调用拆出去,命令执行本身依然是单线程。
约束是「处理足够快」,所以设计选「最少线程」。
Nginx 走的是另一条路:master-worker 多进程,每个 worker 进程各自持有一个事件循环,也可以由 master 统一 accept 后再分发。它面对的约束是:既要吃满多核,又希望进程级隔离——一个 worker 崩了,不能把别人一起拖死。所以它选择的是多进程,而不是多线程;但每个进程内部,依旧是单 Reactor。
约束是「隔离 + 多核」,所以设计选「多进程 + 进程内单 Reactor」。
Kafka 则在更靠右的位置:单条请求的处理代价明显更重——要成帧、要落盘、可能还要等 ISR,远不是微秒级内存操作。如果只用单 Reactor,慢处理很容易同时拖住 accept,于是它把 accept 单独拎出来作为 Acceptor,再用多个 Processor 去分摊连接(也就是 num.network.threads),而真正更慢的业务处理,则推给阻塞式 Handler 线程池去完成。
约束是「请求更重、连接更多、部署在多核机器上」,所以设计选「主从 Reactor + 独立处理池」。
约束不同,设计自然就不同:
- 请求越轻,越敢少线程;
- 隔离要求越强,越倾向多进程;
- 请求越重、连接越多,越需要把「接收 / 读写 / 处理」三段拆开。
拿着这把尺子,再去看任何网络框架的线程模型,就不至于只看到一堆参数和线程名,而能看见它背后的取舍。
工程启示
用好 Kafka:num.network.threads 的本质,是「起几个 Sub Reactor」。
这是这一篇原理最直接的落点。Kafka 的每个 Processor,本质上就是一个独占 Selector 的 Sub Reactor;num.network.threads 决定的,不是「有多少条线程帮你多读点字节」,而是「把连接拆成几摊,每摊交给一个独占 Selector 的 Processor 去看」。
理解了这一层,两件事就不再玄学:
第一,为什么某些场景下增加 Processor 会有效。
当连接数很多、单个 Processor 的 select 与读写处理已经开始排队时,多开几个 Sub Reactor,确实能把连接压力分散掉。
第二,为什么 Kafka 的并发边界是现在这个样子。
每条连接只属于一个 Processor,所以 05 篇下篇里响应必须按 processor id 查表回投,而不是随便找一条线程去写回 socket。
因此,扩不扩 num.network.threads,最好不要拍脑袋,而要看 NetworkProcessorAvgIdlePercent 这种指标是不是已经贴地。
设计借鉴:非阻塞 + 就绪事件,仍然是绝大多数高并发服务的地基。
Selector 把「等数据」从「占住一条线程」变成「让内核替我盯着,等就绪了再叫我」,线程数于是和连接数解耦。这是 C10K 之后几乎一切高并发网络服务的共同起点——无论上层包的是裸 NIO、Netty,还是别的框架。
第二个非常值得借鉴的模式,是 Buffer 的显式状态机。flip / compact 把「读写进度」摊在程序员面前,表面上更麻烦,换来的却是:
- 对内存布局更强的控制力;
- 对半包 / 半写的直接表达能力;
- 以及后续切到堆外内存、进一步做 Zero Copy 的空间。
这也是 Java NIO 很典型的一种气质:它把复杂度留给程序员,但也把控制权一起交给程序员。至于这笔交易值不值,Netty 给出了另一种答案——用回调和抽象把状态机包起来,换一个更舒适的编程模型。这部分对照,留到 08 篇再展开。
至于虚拟线程,它给这个问题又加了第三个选项。但别忘了,它脚下踩的仍然是同一套地基。真要在工程里选,先对齐两件事:
- 版本基线是不是已经到了 JDK 21+;
- 负载形态到底是「线程账更贵」,还是「IO 模型本身更贵」。
这笔账,前文已经算过。
小结
BIO 用「一连接一线程」把线程数直接绑死在连接数上,于是撞上 C10K 这堵墙。NIO 的突破,则来自三件套:
Buffer用三个指针把读写进度变成显式账本;Channel提供了双向、且可切换为非阻塞的传输口;Selector则让一个线程得以靠「就绪事件」看住一批连接。
内核侧,Linux 用 epoll 以「注册 + 就绪回调」的方式,替代了 select / poll 的全量扫描;JDK 里对应的是 EPollSelectorImpl,而它的 wakeup 实现,竟然是一个自带注册的 eventfd。把这套原语按「谁 accept、读写分几摊」组合起来,就是 Reactor 的三种形态。而 Kafka 的 Acceptor / Processor,正是主从 Reactor 的实现。
echo 实验里那条「800 条连接对二三十条线程」的曲线,是整篇里最硬的一条证据。至于后来把 Reactor 藏进运行时的两拨人——JVM 的 Poller 与 Go 的 netpoller——底下踩的,也还是同一块 epoll / kqueue 地基。对照留给番外,这里先把主线收住。
现在,地基已经铺好了。接下来就该回头补上 05 篇留下的那个尾巴:Kafka 自己那层 Selector,到底在 JDK Selector 之上又加了什么?它是怎么攒字节、怎么成帧、mute / unmute 又是怎么真正落到 interestOps 上的?
这些「字节流转」的细节,正好接上这一篇里的 Buffer 与 Selector。
下一篇:Kafka 的 NIO 封装:KSelector 与字节流转。