【Kafka 源码手记】06 Java NIO 原理:从 BIO 到 Reactor

0 阅读35分钟

在 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 条连接不是排队,就是等前面某条连接处理完。连接数一旦长期高于线程数,线程池就只是一块遮羞布:它把「线程爆炸」换成了「连接排队」,模型本身并没有变。

BIO:一个连接一个线程

线程池是 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 的三个指针与状态迁移转存失败,建议直接上传图片文件

这里还有一个实现层面的分叉,需要我们关注。

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」):

  1. 把通道注册到 Selector 上,并声明「我关心哪类事件」,通过 interestOps 表达——OP_ACCEPT(新连接)、OP_READ(可读)、OP_WRITE(可写)、OP_CONNECT(连接建立完成);
  2. 调用 select()——阻塞在这里,直到至少一个已注册通道发生了你关心的事件;
  3. 从 selectedKeys() 取出本轮就绪的 key,逐个处理;
  4. 处理完后,把 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 越大,每次调用的拷贝和扫描成本就越接近 O(n)O(n)。你有一万条连接,即使其中只有一条真的有数据可读,每次也得把一万条全扫一遍。

epoll 换了个思路:把「注册」和「等待」拆开。

  • epoll_ctl:把关心的 fd 登记进内核,只做一次;内核内部为这个 fd 维护就绪关系;
  • epoll_wait:真正等待时,只取回「已经就绪」的那批 fd。

因此,连接总数再大,只要活跃连接比例不高,epoll_wait 的成本就基本和「总连接数」脱钩,而更接近「本轮就绪了多少个 fd」。这就是 NIO 能扛住 C10K 的内核基础。

select / poll 与 epoll 的差别

落到 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 篇真正接起来。

  1. NUM_EPOLLEVENTS:就绪事件是分批取回的

NUM_EPOLLEVENTS 表示一次 epoll_wait 最多取回多少个事件,它的值是 Math.min(IOUtil.fdLimit(), 1024),也就是 fd 上限和 1024 之间取较小值。

为什么要有这个上限?因为 epoll_wait 会把结果填进一块固定大小的 native 内存 pollArray,容量必须预先定死。这也意味着,「就绪集合」不是无限大的一次性结果,而是分批取回的。

  1. processUpdateQueue:register / interestOps 并不会立刻通知内核

这是我第一次读 NIO 时最困惑的地方之一:register() 和 interestOps() 看起来只是普通方法调用,那它们到底什么时候真正通知内核?

答案是:并不会立刻通知。

processUpdateQueue 告诉我们,JDK 会先把这些变更攒进 updateKeys 队列,等到下一次 doSelect 开头时,再统一通过 epoll_ctl 去做 EPOLL_CTL_ADD / MOD / DEL。

这也解释了为什么 05 篇里很多「改完 interestOps」的地方,旁边往往紧跟着一个 wakeup():因为如果不把阻塞在 epoll_wait 里的线程叫醒,它根本没有机会回过头来处理你刚刚提交的变更。

  1. 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 单独拎出去就很自然了。

Reactor 的三种形态

现在回头看 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:只 acceptmain() 独占 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≈ 800160000 / 06.3 s25300 msg/s26.6 / 25.9 / 118.6 ms
② 单 Selector≈ 25160000 / 06.8 s23500 msg/s29.9 / 27.9 / 62.3 ms
③ Reactor(8)≈ 30160000 / 08.1 s19900 msg/s36.0 / 33.3 / 90.4 ms
④ 主从(3)≈ 30160000 / 03.9 s41400 msg/s15.7 / 14.0 / 66.3 ms
⑤ 虚拟线程≈ 30(平台线程)160000 / 023.1 s6935 msg/s104.8 / 92.9 / 255.5 ms

⑤ 这一行是后来单独测的:同一套脚本、同一台机器,先后在 JDK 22 和 JDK 25 下各跑过一轮,表里取的是 JDK 25 那轮。两轮机器都带着后台负载,所以绝对值整体偏低;例如 JDK 25 那轮里,同轮复测 ① 也只有约 6650 msg/s,而不是上表中的 25300。因此,⑤ 和 ① 的对比要以“同轮”结果为准;而 ①–④ 之间的横向比较,仍以原表为准。

echo 服务的四步演进

先看最扎眼的一列:线程数。

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 与字节流转。