内容总览
一、起源:阻塞式 IO 的资源矛盾
1. 一连接一线程的模型
最直观的网络服务端写法是"每个连接分配一个线程":
ServerSocket server = new ServerSocket(8080);
while (true) {
Socket client = server.accept(); // 阻塞,直到有新连接
new Thread(() -> {
try (InputStream in = client.getInputStream()) {
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) != -1) { // 阻塞,直到有数据或连接关闭
handle(buf, len);
}
} catch (IOException e) {
// 连接异常
}
}).start();
}
这段代码的正确性没有问题,问题出在资源模型上。
2. 两个方向的阻塞
上面的模型有两处阻塞:
accept()阻塞。没有新连接时,接受连接的主线程停在accept()上。这一处阻塞可以通过单独的接受线程缓解,不是主要矛盾。read()阻塞。这是核心矛盾。数据未到达时,处理该连接的线程只能停在read()上,直到对端发来数据或关闭连接。
阻塞本身不是问题,用独立线程去承担阻塞才是问题。每个连接独占一个线程,意味着:
| 资源 | 成本 |
|---|---|
| 线程栈内存 | 每个平台线程默认保留 512 KB~1 MB 的栈空间(-Xss 可调),1 万个连接即 5~10 GB |
| 线程对象与内核结构 | 每个线程在 JVM 与内核中各有一份元数据(栈、任务结构体、寄存器上下文) |
| 上下文切换 | 线程数超过 CPU 核数后,切换到被唤醒的线程需要保存/恢复寄存器与刷新 TLB、缓存,单次约数微秒,且缓存命中率下降 |
| 调度开销 | 大量线程同时就绪时,调度器本身的运行时间不可忽略 |
而真实业务中,同一时刻只有少量连接是真的"有数据可处理",其余线程都停在 read() 上等待。线程资源被大量闲置,却又真实占用内存并参与调度。
这就是 C10K 问题的内核:不是操作系统做不了 1 万个连接,而是"一连接一线程"的组织方式让连接数与线程数绑定在一起。
3. 需要新的 IO 组织方式
如果能让少量线程同时"看住"大量连接,只在连接真正就绪时才去处理,线程数就与连接数解耦了。这一思路的实现依赖三个前置条件:
- 操作系统提供"等待多个 fd 就绪"的能力——即 IO 多路复用(
select/poll/epoll) - fd 可以工作在非阻塞模式——读不到数据时立刻返回,而不是挂起线程
- 应用层的读写接口能从"流"改为"缓冲区 + 事件回调"——即 Java NIO 的
Channel/Buffer/Selector
前两条属于操作系统能力,第三条属于语言运行时。Java 1.4 引入 NIO 补齐了第三条,Netty 则在此之上补齐了"事件模型 + 编解码 + 连接治理"的工程化部分。
关于网络编程的概念基础(四要素、C/S 模型、传输层与应用层两个层次),见 网络编程是什么;Socket 与协议栈的关系、bind / listen / accept 的语义,见 Socket 核心概念笔记。
二、原理
1. IO 模型分类
1.1 两个阶段
任何一次网络读取都可以拆成两个阶段:
阶段一:数据准备
内核等待数据到达网卡 → 网卡中断 → 协议栈逐层解包 → 放入该 socket 的接收缓冲区
阶段二:数据拷贝
内核把接收缓冲区中的数据拷贝到用户态缓冲区(应用程序提供的 byte[] 或 ByteBuffer)
五类 IO 模型的差别,本质上就是这两个阶段里进程是否被阻塞。
1.2 五种模型的差别
| 模型 | 阶段一(数据准备) | 阶段二(数据拷贝) | 内核支持 |
|---|---|---|---|
| 阻塞 IO(Blocking IO) | 阻塞 | 阻塞 | read 默认行为 |
| 非阻塞 IO(Non-blocking IO) | 轮询返回(EAGAIN) | 阻塞 | O_NONBLOCK |
| IO 多路复用(Multiplexing) | 阻塞在 select / epoll_wait | 阻塞 | select / poll / epoll |
| 信号驱动 IO(Signal-driven) | 不阻塞,收到 SIGIO 后处理 | 阻塞 | SIGIO + O_ASYNC |
| 异步 IO(Asynchronous IO) | 不阻塞 | 不阻塞 | POSIX AIO / io_uring / IOCP |
关键区分点:
- 前四种都阻塞在阶段二。
select/epoll只是解决了"等待哪个 fd 就绪"的问题,就绪之后真正把数据搬回用户态的那次拷贝,仍然是同步阻塞的。因此 IO 多路复用常被称为"同步非阻塞 + 多路复用",而不是异步 IO。 - 只有异步 IO 把两个阶段都交给内核。应用提交读请求后立即返回,内核完成数据准备与拷贝,再用回调、信号或完成队列通知应用。
信号驱动 IO 在实际工程中很少使用:信号处理函数的可重入限制、信号丢失与竞态、调试困难,使其在通用服务端代码里处处不便。
1.3 Java 中的对应实现
| Java 技术 | 对应模型 | 引入版本 | 核心 API |
|---|---|---|---|
| BIO(传统 IO) | 阻塞 IO | 1.0 | java.net.Socket、InputStream / OutputStream |
| NIO | IO 多路复用 | 1.4 | java.nio.channels.*、ByteBuffer、Selector |
| NIO.2 / AIO | 异步 IO | 7 | AsynchronousSocketChannel、CompletionHandler |
关于 AIO 有一个必须澄清的实现差异:在 Linux 上,JDK 的 AIO 并非基于内核原生异步 IO,而是在 epoll 之上用内部线程池模拟出"回调"语义。也就是说,Linux 上 AIO 的线程成本并没有真正消失,只是从"每连接一个线程"变成了"固定线程池 + 任务队列"。Windows 上则对应 IOCP 这类真正的完成端口模型。
这一差异是 Netty 长期不支持(并最终移除)AIO 传输的重要背景:在 Linux 生产环境中,基于 AIO 的实现没有可证明的性能优势,反而多了一层封装。至于 JDK 22 之后引入的 io_uring 相关探测,属于较新的演进,尚未成为主流选型依据。
1.4 操作系统的多路复用支撑
select / poll / epoll 的差异决定了高并发场景的天花板。
| 对比项 | select | poll | epoll |
|---|---|---|---|
| 数据结构 | fd_set 位图(固定大小) | pollfd 数组 | 内核红黑树 + 就绪链表 |
| fd 数量上限 | FD_SETSIZE,通常 1024 | 无固定上限,受内存限制 | 无固定上限,受内存与 ulimit -n 限制 |
| 每次调用 | 传入并复制整个 fd 集合,返回后需重置 | 同左 | epoll_ctl 注册一次,epoll_wait 只取就绪项 |
| 复杂度 | O(n) 扫描全部 fd | O(n) 扫描全部 fd | O(1) 取就绪 fd(与总连接数无关) |
| 触发模式 | 只有水平触发 | 只有水平触发 | 支持水平触发(LT)与边沿触发(ET) |
| 触发通知 | 内核修改 fd_set 位 | 内核修改 revents 字段 | 就绪项挂入链表,epoll_wait 出队 |
epoll 的两项能力是关键:
- 注册与等待分离。fd 通过
epoll_ctl加入内核的红黑树,只需注册一次;epoll_wait无需重复拷贝整个集合,扫描的对象是就绪链表而非全部 fd。 - 边沿触发(ET)。数据从"无"变为"有"时通知一次,之后不再重复通知,要求应用一次把数据读干净(循环读到
EAGAIN)。水平触发(LT)则在数据未读完时持续通知,编程更简单但可能产生更多系统调用。
TCP/IP 协议栈的分层封装、TCP 的连接建立与关闭、Nagle 与延迟确认、套接字缓冲区的内核参数,见 Linux 网络。
2. Java NIO 三件套
2.1 Channel
Channel 表示一个可以读写的连接(或文件),替代了 BIO 中的 InputStream / OutputStream 二元结构:
| 实现 | 用途 | 阻塞模式 |
|---|---|---|
SocketChannel | TCP 客户端连接 / accept 返回的服务端连接 | 可设置为非阻塞 |
ServerSocketChannel | TCP 监听 | 可设置为非阻塞 |
DatagramChannel | UDP | 可设置为非阻塞 |
FileChannel | 文件读写 | 只有阻塞模式 |
Pipe.SourceChannel / SinkChannel | 线程间管道 | 可设置为非阻塞 |
与 BIO 的关键差别:
- 双向。同一个
Channel既可读也可写,不需要getInputStream()/getOutputStream()两个对象。 - 可非阻塞。
configureBlocking(false)之后,读写方法在无法立即完成时返回 0 或null,而不是挂起线程。注意FileChannel是例外,它无法设置非阻塞模式,这是文件 IO 与网络 IO 在"就绪"概念上的根本差别。 - 面向缓冲区。读写方法以
ByteBuffer为参数,一次调用搬运的是一段数据,而不是流模型下的单字节/字节数组。
2.2 Buffer
Buffer 是 NIO 的数据载体。它的核心是四个索引:
0 position limit capacity
├─────────────────┼─────────────────┼─────────────────┤
│ 已读/已写数据 │ 剩余可读写空间 │
└─────────────────┴─────────────────┴─────────────────┘
↑ ↑
position limit
| 索引 | 含义 |
|---|---|
capacity | 缓冲区总容量,创建后不变 |
position | 下一个要读或写的位置 |
limit | 不可越过的边界:写模式下等于 capacity,读模式下等于已写入数据的末端 |
mark | 一个可回退的备忘位置,由 mark() 设置、reset() 恢复 |
读写模式切换是 NIO 最容易出错的地方。ByteBuffer 没有独立的读指针和写指针,它通过复用 position / limit 来表达"现在处于哪种模式":
| 方法 | 效果 | 使用时机 |
|---|---|---|
flip() | limit = position;position = 0;丢弃 mark | 写完数据、准备读取(写模式 → 读模式) |
clear() | position = 0;limit = capacity;丢弃 mark | 数据已全部读完、准备重新写入(读模式 → 写模式) |
compact() | 把未读数据前移到起始位置,position = 剩余字节数,limit = capacity | 数据只读了一部分、准备继续写入(保留未读数据) |
rewind() | position = 0,limit 不变 | 重新读一遍同一段数据 |
mark() / reset() | 记录 / 回到 mark 位置 | 需要回退重读(如协议解析试探) |
clear() 与 compact() 的差别是解析类代码的常见 bug 来源:clear() 会丢弃未读数据,只有在确认数据已读完时才可使用;一次 read 只读到半个消息就调用 clear(),剩余半个消息会被静默丢掉,表现为"偶发的解析错乱"。正确做法是调用 compact() 保留未读部分。
一个标准的读写循环:
ByteBuffer buf = ByteBuffer.allocate(1024);
// 写:channel 把数据写入 buffer
int n = channel.read(buf);
if (n > 0) {
buf.flip(); // 切换到读模式
while (buf.hasRemaining()) {
process(buf.get());
}
buf.clear(); // 全部读完,准备下次写入
}
2.3 Selector
Selector 是"一个线程看住多个 Channel"的实现载体。
Selector selector = Selector.open();
channel.configureBlocking(false); // 必须先设为非阻塞
channel.register(selector, SelectionKey.OP_READ, attachment);
四种就绪事件:
| 事件 | 常量值 | 含义 |
|---|---|---|
OP_READ | 1 | 可读(有数据到达或对端关闭) |
OP_WRITE | 4 | 可写(发送缓冲区有空闲) |
OP_CONNECT | 8 | 客户端连接建立完成 |
OP_ACCEPT | 16 | 有新的连接待接受(仅 ServerSocketChannel) |
为什么几乎不注册 OP_WRITE:绝大多数情况下发送缓冲区都是可写的,若长期注册 OP_WRITE,select 会每次都返回就绪,造成 100% CPU 空转。正确做法是只在"确实有数据没写完"时临时注册 OP_WRITE,写完立即取消。
事件循环骨架:
Selector selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));
server.configureBlocking(false);
server.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
int ready = selector.select(); // 阻塞,直到有事件或超时
if (ready == 0) continue;
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
it.remove(); // 必须移除,否则会被反复处理
if (!key.isValid()) continue;
if (key.isAcceptable()) {
SocketChannel client = ((ServerSocketChannel) key.channel()).accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
handleRead(key);
} else if (key.isWritable()) {
handleWrite(key);
}
}
}
两个必须遵守的细节:
it.remove()不能省略。selectedKeys()返回的集合由Selector维护,不会在select()时自动清空。不移除会导致同一个 key 被反复处理。key.channel()必须转为对应的具体类型。OP_ACCEPT只在ServerSocketChannel上触发,OP_READ/OP_WRITE在SocketChannel上触发。
Selector 与 Channel 的注册关系不是线程安全的:同一 Selector 上的 register 与 select 并发执行会导致阻塞或异常,必须通过 wakeup() + 任务队列把注册操作交给 selector 线程执行。这个约束直接决定了后续 Reactor 模型的形态。
2.4 直接缓冲区与堆缓冲区
| 类型 | 创建方式 | 内存位置 | 分配/释放成本 | 适用场景 |
|---|---|---|---|---|
| 堆缓冲区 | ByteBuffer.allocate(n) | JVM 堆 | 低(由 GC 管理) | 数据主要在 JVM 内部流转 |
| 直接缓冲区 | ByteBuffer.allocateDirect(n) | 堆外本地内存(malloc 系) | 高(分配与释放都要走系统调用,靠 Cleaner 回收) | 需要与操作系统做 IO 交换的数据 |
关键差别在是否多一次拷贝:
- 使用堆缓冲区做 IO 时,内核无法直接写入 JVM 堆(堆对象会因 GC 移动),因此数据必须先进入一个临时的本地内存区,再由 JVM 复制到堆内。这次复制是纯开销。
- 直接缓冲区的地址固定,内核可以(在支持的前提下)直接读写,省掉上述复制,也避免了 JNI 调用边界上的额外拷贝。
直接缓冲区的代价:
- 分配与释放昂贵。每次
allocateDirect都是一次本地内存分配;释放依赖Cleaner(虚引用 + 引用队列),时机由 GC 决定,不透明。因此在请求路径上反复创建直接缓冲区是常见的性能陷阱,应当复用(Netty 的ByteBuf池化正是为此)。 - 统计困难。堆外内存不计入堆,
-Xmx管不到它,其上限由-XX:MaxDirectMemorySize控制;未设置时默认上限约等于-Xmx。这意味着一个 8 GB 堆的 JVM 默认可以再占用 8 GB 直接内存,总占用 16 GB。 - 是 OOM 的独立来源。堆内还很空时也可能收到
java.lang.OutOfMemoryError: Direct buffer memory。
3. Reactor 模式
Reactor 模式把"等待就绪 → 分发处理"抽象成事件循环,是 NIO 服务端的标准组织方式。
3.1 单 Reactor 单线程
┌─────────────────────────┐
连接 ──────→ │ Reactor(单线程) │
│ select → 分发 → 处理业务 │
└─────────────────────────┘
只有一个线程完成 accept、read、业务处理、write 的全部工作。
- 优点:实现最简单,无并发问题,无锁
- 缺点:业务处理稍慢就会阻塞整个事件循环,其他连接全部等待;无法利用多核
- 适用:连接数少、业务逻辑极轻的场景(如心跳服务器、简单的 Echo 服务)
Redis 的单线程模型在思路上与此接近:把网络事件与命令处理放在同一线程串行执行,从而彻底回避数据竞争。
3.2 单 Reactor 多线程
┌─────────────────────────┐
连接 ──────→ │ Reactor(单线程) │
│ select → 分发(只做 IO) │
└───────────┬─────────────┘
│ 提交任务
┌───────────▼─────────────┐
│ 业务线程池 │
└─────────────────────────┘
Reactor 线程只负责 select 与读写,业务逻辑交给线程池。事件循环不再被业务阻塞,多核得到利用。
新的问题:同一连接的读写事件可能与业务线程并发操作同一份数据,需要引入锁或串行化机制;线程池的队列长度、拒绝策略、任务顺序性都需要额外设计。
3.3 主从 Reactor 多线程
┌───────────────────────────┐
连接 ──────→ │ mainReactor(1 个线程) │
│ select → accept → 注册 │
└─────────────┬─────────────┘
│ 分发新连接到某个 subReactor
┌─────────────▼─────────────┐
│ subReactor 组(N 个线程) │
│ 每个线程管理一批连接的读写 │
└───────────────────────────┘
accept 与"连接上的读写"被拆到不同的线程组:mainReactor 只处理新连接,subReactor 各自负责一批已建立连接的 IO 事件。
这是 Netty 的默认形态:bossGroup 对应 mainReactor(通常 1 个线程足够,因为 accept 的工作量很小),workerGroup 对应 subReactor 组(默认 CPU 核数 × 2 个线程)。
3.4 事件循环与任务队列
Netty 的 EventLoop 是"Selector + 单线程 + 任务队列"的组合:
EventLoop(单线程)
while (!terminated) {
① 运行任务队列中的任务(提交的 Runnable、定时任务)
② selector.select(timeout)
③ 处理就绪事件,调用 pipeline 上的 handler
④ 回到 ①
}
这个结构带来一个重要保证:一个 Channel 在生命周期内只绑定一个 EventLoop,因此该 Channel 上的所有事件处理都是同一个线程串行执行的。业务代码在 handler 内不需要为同一个连接加锁,这是 Netty 编程模型简单性的来源。
需要注意这个保证的边界:
- 它只保证同一 Channel 内的串行,不同 Channel 之间仍然并发
- 一旦把 handler 加到独立的业务
EventExecutorGroup上(见第三部分第 2 小节),该 handler 在同一个 Channel 上的事件会固定由业务组中的某一个线程执行,串行保证转移到那个线程;但事件在 IO 线程与业务线程之间发生了交接,handler 之间共享的可变状态需要重新审视 - 从其他线程直接操作
Channel(如channel.write())会被包装成任务投递到该 Channel 所属的EventLoop,不会立即执行,因此write()返回的ChannelFuture才是判断完成时机的正确依据
与 Reactor 相对的另一种模式是 Proactor:应用只提交异步请求、由系统在完成后回调,对应 Windows 的 IOCP 与 POSIX AIO。Reactor 面向"就绪"事件,Proactor 面向"完成"事件,这也是第 1 小节中"同步非阻塞 vs 异步"这一区分的模型化表达。
4. 零拷贝
4.1 传统读写路径的拷贝次数
一次"把磁盘文件通过 socket 发出去"的操作,用最朴素的 read + write 实现:
byte[] buf = new byte[8192];
int len;
while ((len = in.read(buf)) != -1) {
out.write(buf, 0, len);
}
数据实际经过的路径:
① DMA 拷贝:磁盘 → 内核页缓存
② CPU 拷贝:内核页缓存 → 用户缓冲区(buf)
③ CPU 拷贝:用户缓冲区 → 内核 socket 发送缓冲区
④ DMA 拷贝:socket 发送缓冲区 → 网卡
同时发生 4 次上下文切换(read 进入/退出内核各一次,write 进入/退出内核各一次)与 4 次拷贝(2 次 DMA、2 次 CPU)。
CPU 拷贝不搬运业务的任何语义,纯属从"内核缓冲"到"用户缓冲"再回"内核缓冲"的往返。零拷贝要消除的正是第 ②③ 步。
相关背景(页缓存、Buffered IO 与 Direct IO 的差别、脏页回写)见 页缓存与 IO 性能。
4.2 mmap + write
用 mmap 把内核页缓存映射到用户地址空间,应用直接操作页缓存,省掉第 ② 步的 CPU 拷贝:
① DMA 拷贝:磁盘 → 内核页缓存
② (无拷贝:用户地址空间与页缓存映射同一块物理页)
③ CPU 拷贝:页缓存 → socket 发送缓冲区
④ DMA 拷贝:socket 发送缓冲区 → 网卡
- 拷贝:2 次 DMA + 1 次 CPU = 3 次
- 上下文切换:4 次(
mmap一次、write一次,加上对应返回) - 注意仍然存在第 ③ 步的 CPU 拷贝,并未完全消除
Java 对应实现是 MappedByteBuffer:
try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
MappedByteBuffer mapped = channel.map(
FileChannel.MapMode.READ_ONLY, 0, channel.size());
// mapped 是内核页缓存的一个映射视图,读取不产生用户态拷贝
}
适用场景:需要读取或修改文件内容的场合(如本地索引文件、内存映射的数据库文件)。mmap 的局限是文件大小受地址空间限制、映射的释放时机不透明(Cleaner),且大文件映射会增加缺页中断的处理压力。
4.3 sendfile
sendfile 让内核直接把页缓存中的数据传给 socket 发送缓冲区,数据完全不进入用户态:
① DMA 拷贝:磁盘 → 内核页缓存
② CPU 拷贝:页缓存 → socket 发送缓冲区
③ DMA 拷贝:socket 发送缓冲区 → 网卡
- 拷贝:3 次(2 次 DMA + 1 次 CPU)
- 上下文切换:2 次(只有一次系统调用)
若网卡支持 scatter-gather DMA(SG-DMA),第 ② 步的 CPU 拷贝也可省去:内核只把数据在页缓存中的地址与长度告知网卡,网卡直接从页缓存读取。
① DMA 拷贝:磁盘 → 内核页缓存
② (无拷贝:内核只传递描述符)
③ DMA 拷贝(Gather):页缓存 → 网卡
- 拷贝:2 次,全部是 DMA,CPU 拷贝次数为 0
- 上下文切换:2 次
这是严格意义上的"零拷贝"——CPU 不参与数据搬运。
Java 的对应 API 是 FileChannel.transferTo / transferFrom:
try (FileChannel file = FileChannel.open(path, StandardOpenOption.READ);
SocketChannel socket = SocketChannel.open(address)) {
long position = 0;
long size = file.size();
while (position < size) { // 单次传输有上限,需要循环
long transferred = file.transferTo(position, size - position, socket);
if (transferred <= 0) break;
position += transferred;
}
}
使用要点:
- 必须循环调用。单次
transferTo能传输的字节数受内核限制(Linux 上sendfile的单次上限约为 2 GB),大文件必须循环 - 平台差异。在 Linux 上,
FileChannel到SocketChannel的transferTo会走sendfile;在 Windows 上走TransmitFile;若目标不是SocketChannel(如另一个FileChannel),则可能退化为普通拷贝 transferTo需要目标 socket 处于阻塞模式才能发挥最大效果,在 Netty 中需配合ChunkedWriteHandler或FileRegion
4.4 三种方式的对比与选型
| 方式 | CPU 拷贝次数 | 上下文切换 | 数据能否被修改 | 适用场景 |
|---|---|---|---|---|
read + write | 2 | 4 | 可以 | 通用场景,需要在用户态加工数据 |
mmap + write | 1 | 4 | 可以 | 需要修改文件内容;文件映射式访问 |
sendfile | 1(支持 SG-DMA 时为 0) | 2 | 不可以 | 纯转发,如文件下载、静态资源服务 |
splice | 0 | 2 | 不可以 | 两个 fd 之间经管道搬运(如代理转发) |
关键限制:sendfile 要求数据不被修改。这带来一个重要的工程结论:启用 TLS 之后不能直接使用 sendfile,因为加密需要读取并修改明文字节。TLS 场景的常见处理是退回普通拷贝路径,或使用内核态的 kTLS(把加解密下沉到内核,从而恢复 sendfile 的可能)。
Java 生态中的应用实例:消息中间件的日志数据发送、对象存储/网关的大文件下载、Nginx 的 sendfile on 静态资源服务,都依赖这条路径。
5. TCP 粘包与半包
5.1 成因
"粘包"这个名字容易误导——TCP 是面向字节流的协议,它根本没有"包"的概念,因此也谈不上"粘"。真正的问题是:
TCP 只保证字节的顺序与到达,不保留应用层消息的边界。
发送方写三次 write("A")、write("B")、write("C"),接收方可能一次读到 "ABC",也可能分三次读到 "A"、"BC"、"",还可能读到 "AB" 后再读 "C"。以下因素都会改变分片结果:
| 因素 | 影响 |
|---|---|
| 发送方 Nagle 算法 | 小数据段被合并发送,等待 ACK 或累积到一个 MSS 再发出 |
| MSS 分段 | 超过最大报文段长度的数据被切成多段(MTU 1500 → MSS 1460) |
| 接收方读取时机 | 应用读取的频率与到达频率不一致时,多次到达的数据会被一次性读出 |
| 网络 MTU 路径差异 | 中间链路 MTU 较小时发生分片重组 |
| 收发缓冲区大小 | 影响内核一次能聚合多少数据 |
Nagle 与延迟确认(Delayed ACK)的交互值得单独注意:发送方等 ACK 才发小包、接收方等数据才捎带 ACK,两者叠加会在"写-写-读"模式下引入数十毫秒的额外延迟。延迟敏感的应用需要开启 TCP_NODELAY 关闭 Nagle。相关机制见 Linux 网络 传输层章节。
5.2 三个子问题
处理粘包需要同时解决三件事:
- 如何确定消息边界(协议设计)
- 如何在数据不足时缓存并等待(读缓冲管理)
- 如何在写出时处理"没写完"(写缓冲管理)
第 3 点常被忽略,但同样属于"包边界"问题:write 不一定一次写完所有字节,返回值是实际写入的字节数,可能小于请求长度。
5.3 三种解法
方案一:定长消息
每条消息固定 N 字节,不足补齐。
┌──────────┬──────────┬──────────┐
│ 8 byte │ 8 byte │ 8 byte │
└──────────┴──────────┴──────────┘
- 优点:解析极简单,无需扫描;每次读取 N 字节即可
- 缺点:长度固定导致浪费(短消息补齐)或截断(超长消息需分片);扩展性差
- 适用:协议字段固定的二进制场景(如某些硬件协议、定长的行情快照)
方案二:分隔符
用特殊字节序列(如 \n、\r\n)标记消息结束。
消息体 A \r\n 消息体 B \r\n 消息体 C \r\n
- 优点:可读性好,文本协议常用(HTTP 头、Redis 的 RESP 协议、SMTP)
- 缺点:需要在消息体内对分隔符做转义,否则提前截断;解析需要逐字节扫描,且有长度上限(否则超长无分隔符的流会无限占用内存)
- 实现要点:必须设置最大帧长度,防止恶意构造的无分隔符数据流耗尽内存
方案三:长度字段
在消息头部携带长度,接收方先读长度、再读满整个消息体。
┌──────────┬──────────────────────────┐
│ 4 byte │ N byte(N = 长度字段的值) │
│ 长度 N │ 消息体 │
└──────────┴──────────────────────────┘
- 优点:最通用、可处理任意二进制内容、无需转义、可支持内存预分配
- 缺点:需要考虑长度字段自身的半包(先读满 4 字节);需要防御性校验(长度字段被伪造为极大值时不能直接分配缓冲区)
- 变体:长度字段位置可变、长度是否包含头部、是否需要在长度前后补字节,这就是 Netty
LengthFieldBasedFrameDecoder五个参数的来源
| 方案 | 边界确定成本 | 是否需转义 | 长度上限保护 | 适用协议 |
|---|---|---|---|---|
| 定长 | O(1) | 不需要 | 天然有 | 固定格式二进制协议 |
| 分隔符 | O(n) 扫描 | 需要 | 必须显式设置 | 文本协议、命令行协议 |
| 长度字段 | O(1) | 不需要 | 必须显式校验 | 通用二进制协议、RPC、MQ |
5.4 读缓冲与写缓冲的处理
读侧:每个连接必须维护一个累积缓冲区,把每次 read 到的数据 append 进去,然后循环尝试解码;解出的消息交给业务,剩余的尾部留待下次读取。
ByteArrayOutputStream pending = new ByteArrayOutputStream();
void onReadable(SocketChannel ch) {
ByteBuffer buf = ByteBuffer.allocate(4096);
int n = ch.read(buf);
if (n == -1) { close(ch); return; } // 对端关闭
buf.flip();
byte[] bytes = new byte[buf.remaining()];
buf.get(bytes);
pending.write(bytes);
byte[] data = pending.toByteArray();
int offset = 0;
while (true) { // 一次可能解出多条消息
if (data.length - offset < 4) break; // 长度字段都没读全
int len = ((data[offset] & 0xff) << 24) | ((data[offset + 1] & 0xff) << 16)
| ((data[offset + 2] & 0xff) << 8) | (data[offset + 3] & 0xff);
if (len < 0 || len > MAX_FRAME) { close(ch); return; } // 长度字段越界
if (data.length - offset - 4 < len) break; // 消息体还没读全
handle(Arrays.copyOfRange(data, offset + 4, offset + 4 + len));
offset += 4 + len;
}
// 保留未消费的部分
// (示例用数组重分配表达语义,生产代码应使用可复用的 Buffer 避免反复复制)
}
这段代码体现了三个要点:循环解码(一次读取可能含多条消息)、长度校验(越界即视为协议错误)、残留保留(compact 语义)。
写侧:write 返回已写入的字节数,若小于请求长度,说明发送缓冲区已满,必须保存剩余数据并等待可写事件再续写。
// 写未完成时的处理
ByteBuffer remaining = ...;
channel.register(selector, SelectionKey.OP_WRITE, remaining);
// OP_WRITE 就绪时续写
void handleWrite(SelectionKey key) {
ByteBuffer buf = (ByteBuffer) key.attachment();
channel.write(buf);
if (!buf.hasRemaining()) {
channel.register(selector, SelectionKey.OP_READ); // 写完立刻取消 OP_WRITE
}
}
忘记处理"写未完成"的后果是静默丢数据:调用方以为已经发出,实际只发出了一部分。忘记取消 OP_WRITE 的后果是 CPU 空转。
6. 背压与连接治理
6.1 背压
背压(backpressure)要解决的是"生产速度超过消费速度":业务持续写入,而对端读取慢或网络拥塞,导致数据在应用层的发送队列中越积越多,内存持续增长,最终 OOM。
背压的手段按从内到外分层:
| 层次 | 机制 | 作用 |
|---|---|---|
| TCP | 接收窗口(rwnd) | 接收方通过通告窗口限制发送方的在途字节数 |
| TCP | 零窗口探测 | rwnd = 0 时发送方周期探测,避免连接僵死 |
| 内核 | SO_SNDBUF / SO_RCVBUF | 单个连接的发送/接收缓冲区上限 |
| 应用 | 可写性判断 | 发送队列积压过多时拒绝或暂停写入 |
| 应用 | 有界队列 + 拒绝策略 | 在任务入口处限流 |
| 业务 | 在途请求数上限 | 从源头限制并发,如信号量、限流器 |
Netty 把"可写性"做成了显式契约:WriteBufferWaterMark 定义高低水位(默认低 32 KB、高 64 KB),当发送队列中的待发字节数超过高水位时 channel.isWritable() 返回 false,ChannelWritabilityChanged 事件被触发。
// 业务写入前判断可写性,实现背压
if (!ctx.channel().isWritable()) {
// 暂停从上游读取(如取消与上游的订阅、暂停投递)
return;
}
ctx.writeAndFlush(msg);
背压的正确姿势是把压力向源头传递:不是继续写入并丢弃,也不是无限缓冲,而是暂停产生数据的一方。在流式处理(如从消息队列消费后再转发)中,这表现为暂停拉取。
6.2 空闲检测与心跳
TCP 是"沉默"的协议:连接的对端进程崩溃、机器断电、中间设备静默丢弃状态,都不会主动通知本端。TCP keepalive 的默认探测间隔在 Linux 上是 7200 秒,对在线业务完全不可用。
因此应用层需要自己探测:
| 机制 | 检测对象 | 典型配置 |
|---|---|---|
| 读空闲(reader idle) | 多久没收到任何数据 | 触发时关闭连接或发探测 |
| 写空闲(writer idle) | 多久没发出任何数据 | 触发时主动发 PING |
| 读写空闲(all idle) | 双向都无活动 | 最严格的判定 |
Netty 的 IdleStateHandler 就是这个能力:
// readerIdleTime / writerIdleTime / allIdleTime,单位秒,0 表示不检测
pipeline.addLast(new IdleStateHandler(60, 30, 0));
配套的 handler 需要判断事件类型并处理:
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent event) {
if (event.state() == IdleState.READER_IDLE) {
ctx.close(); // 超过 60 秒没收到任何数据,判定连接失效
} else if (event.state() == IdleState.WRITER_IDLE) {
ctx.writeAndFlush(PING); // 30 秒没发数据,主动发心跳保活
}
}
super.userEventTriggered(ctx, evt);
}
设计要点:
- 心跳间隔需与对端的读空闲阈值配合。本端写空闲 30 秒发 PING,对端读空闲阈值必须大于 30 秒,否则对端会先把自己的连接判死
- 必须同时有超时关闭逻辑。只发 PING 不判超时,等于没有检测:对端已经失联时,PING 只是不断堆积
- 心跳要计入业务指标。心跳异常上升通常是网络层或对端故障的早期信号
6.3 半关闭与优雅关闭
半关闭指关闭一端的发送方向而保留接收方向。TCP 是全双工协议,FIN 只表示"我不再发送数据",不表示"我不再接收数据"。应用表现为调用 shutdownOutput(),对端读到 EOF,但仍可以继续向本端发送数据。
多数请求-响应式的短连接协议不需要半关闭语义,直接关闭即可。半关闭适用于"客户端发送完毕但仍需接收响应"的场景。若希望关闭时立即丢弃未发送数据并发出 RST(而非正常四次挥手),可设置 SO_LINGER 为 0,但会让对端收到连接重置而非正常关闭,属于有副作用的做法。
优雅关闭的目标是:不再接受新连接、等在途请求处理完、再释放资源。顺序不能颠倒。
// 1. 先关闭监听 socket,停止接受新连接
serverChannel.close().sync();
// 2. 等待在途请求完成(或设定上限,超时后强制关闭)
worker.shutdownGracefully(2, 15, TimeUnit.SECONDS).sync();
// 3. 释放业务线程组与资源
business.shutdownGracefully().sync();
shutdownGracefully 的两个时间参数分别是静默期(默认 2 秒,期间不再接受新任务,让仍在执行的任务收尾)和整体超时(默认 15 秒,到点仍未完成则强制终止)。时间设置过短会丢失在途请求,设置过长会拖慢发布流程。
与关闭相关的两个常见故障:
- 进程退出但没有关闭连接,对端一直等到读超时才发现,表现为"服务重启后客户端出现一批超时"
- 只关闭了 Channel 没有关闭线程组,JVM 无法正常退出,表现为"进程 kill 不掉或长时间不退出"
7. Netty 的定位与核心抽象
7.1 定位
Netty 是一个异步事件驱动的网络应用框架,解决的是"用原生 NIO 写一个健壮的服务端"这件事的全部工程细节:事件循环、连接生命周期、半包处理、写未完成、编解码、引用计数内存管理、连接治理、可观测性。
它不解决协议本身——HTTP、Protobuf、自定义二进制协议的语义仍需应用实现(Netty 为常见的 HTTP/2、WebSocket、Protobuf 提供了编解码器)。
7.2 EventLoop 与 EventLoopGroup
EventLoopGroup(线程组)
├── EventLoop 0 ── Selector + 单线程 + 任务队列 ── 管理 Channel A、C、E
├── EventLoop 1 ── Selector + 单线程 + 任务队列 ── 管理 Channel B、D
└── EventLoop 2 ── ...
EventLoop继承EventExecutor,本身是一个单线程执行器,同时持有一个SelectorEventLoopGroup是EventLoop的容器,NioEventLoopGroup默认线程数为CPU 核数 × 2- Channel 通过
register绑定到一个EventLoop,绑定后不再改变,由此获得"同 Channel 串行"的保证 - 提交到
EventLoop的任务(execute/schedule/scheduleAtFixedRate)会与 IO 事件在同一线程中被顺序处理,因此任务队列中不得有阻塞操作
线程数的选择依据:
| 场景 | 建议 |
|---|---|
workerGroup 通用 | 默认 CPU × 2,兼顾 IO 与轻量计算 |
| 业务偏重计算 | 减少 worker 线程,把业务移到独立业务线程组 |
| 连接数极多但流量小 | 可适当减少线程数(IO 线程空转成本仍在) |
bossGroup | 固定 1 个线程,accept 的工作量不足以需要更多 |
7.3 Channel 与 ChannelPipeline 与 ChannelHandler
入站(Inbound):socket → 业务
┌──────────────┬────────────────┬──────────────┬──────────────┐
│ InboundHandler│ InboundHandler │OutboundHandler│OutboundHandler│
└──────────────┴────────────────┴──────────────┴──────────────┘
出站(Outbound):业务 → socket
| 概念 | 职责 |
|---|---|
Channel | 对一个连接(或 fd)的抽象,提供 read / write / bind / connect / close,所有异步操作返回 ChannelFuture |
ChannelPipeline | ChannelHandler 的双向链表,构成责任链 |
ChannelHandler | 处理逻辑单元,分为入站(ChannelInboundHandler)与出站(ChannelOutboundHandler) |
ChannelHandlerContext | handler 与 pipeline 之间的关联对象,用于向链上的下一个 handler 传递 |
事件传播规则:
- 入站事件(
channelRead、channelActive、exceptionCaught)从 pipeline 头部向尾部传播,即按addLast的添加顺序 - 出站事件(
write、flush、close)从 pipeline 尾部向头部传播 - 出站操作从哪个
ctx发起,就从该节点向上游(更靠近 socket 的方向)传播
两个必须注意的约束:
@Sharable与无状态。handler 默认每个 Channel 独享一个实例;若要复用(@Sharable),必须保证无状态,否则会串数据。exceptionCaught必须实现。默认实现只记录日志并关闭连接;若链上没有任何 handler 处理异常,异常会被丢弃且连接状态不明。异常处理的不完整是"连接无声消失"的常见根因。
7.4 ByteBuf
ByteBuf 是对 ByteBuffer 的替换实现,解决了 ByteBuffer 的三个痛点:
痛点(ByteBuffer) | ByteBuf 的做法 |
|---|---|
读写共用一个 position,需要 flip / clear 切换 | 读写索引分离(readerIndex / writerIndex),读写可交错 |
| 容量固定,扩容需手工搬移 | 支持动态扩容,直到 maxCapacity |
| 无内存池,反复分配开销大 | 提供池化分配器,复用缓冲区 |
| 无可组合能力,聚合数据需要拷贝 | CompositeByteBuf 可零拷贝组合多个缓冲区 |
读写索引模型:
0 readerIndex writerIndex capacity
├─────────────┼─────────────────┼────────────────┤
│ 已读(可被复用) │ 可读数据(未消费) │ 可写空间 │
└─────────────┴─────────────────┴────────────────┘
| 方法 | 效果 |
|---|---|
readBytes(...) | 读,readerIndex 前进 |
writeBytes(...) | 写,writerIndex 前进 |
discardReadBytes() | 丢弃已读部分,readerIndex 与 writerIndex 前移 |
getXxx(i) / setXxx(i, v) | 绝对位置访问,不移动索引 |
slice() / duplicate() | 共享底层内存的视图,零拷贝 |
retainedSlice() / retainedDuplicate() | 视图且递增引用计数 |
引用计数与泄漏。ByteBuf 使用引用计数管理内存(ReferenceCounted 接口),创建时计数为 1,retain() 递增,release() 递减,减到 0 时回收。规则是:
- 谁创建谁释放,或谁最后使用谁释放(
SimpleChannelInboundHandler会自动释放,ChannelInboundHandlerAdapter不会) - 入站消息在链上传给下一个 handler 后,当前 handler 不应再访问(可能已被释放或复用)
- 出站写入
ByteBuf后,释放责任转移给 Netty(除非明确retain)
// 继承 SimpleChannelInboundHandler 会自动 release
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) {
// msg 在本方法返回后由框架自动释放
}
// 继承 ChannelInboundHandlerAdapter 需要手工释放
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
try {
// 处理 msg
} finally {
ReferenceCountUtil.release(msg);
}
}
若忘记释放,Netty 的 ResourceLeakDetector 会打印泄漏报告:
LEAK: ByteBuf.release() was not called before it's garbage-collected.
泄漏检测的级别由系统属性控制,默认 SIMPLE(约 1% 的缓冲区采样):
# 采样率与开销递增:DISABLED < SIMPLE < ADVANCED < PARANOID(始终采样)
java -Dio.netty.leakDetection.level=PARANOID -jar app.jar
高危:PARANOID 级别会对每个缓冲区记录创建位置的堆栈,带来明显的 CPU 与内存开销(通常数倍于 SIMPLE)。影响范围:整个 JVM 的所有网络处理路径,生产环境开启可能导致吞吐下降与延迟上升。回滚方式:改回 SIMPLE 或 DISABLED 并重启;建议只在预发环境或短时排查窗口内开启。
池化与非池化。池化分配器(PooledByteBufAllocator,Netty 4.1 在非 Android 环境下的默认实现)通过线程本地缓存和多级内存规格复用缓冲区,避免频繁分配。
# 显式指定分配器类型
java -Dio.netty.allocator.type=pooled -jar app.jar # 池化(默认)
java -Dio.netty.allocator.type=unpooled -jar app.jar # 非池化
池化带来吞吐收益的同时也放大了泄漏的后果:泄漏的缓冲区不会返回池中,池会持续申请新的本地内存,表现为堆外内存持续增长。
7.5 编解码器层次
字节流
↓ ByteToMessageDecoder 处理半包(累积到可解码为止)
↓ LengthFieldBasedFrameDecoder 按长度字段切出完整帧
↓ MessageToMessageDecoder 反序列化为业务对象
业务对象
| 类型 | 方向 | 典型实现 | 职责 |
|---|---|---|---|
| 半包处理器 | 入站 | ByteToMessageDecoder、LengthFieldBasedFrameDecoder、DelimiterBasedFrameDecoder | 把字节流切成完整帧 |
| 消息解码器 | 入站 | MessageToMessageDecoder、StringDecoder、ProtobufDecoder | 帧 → 业务对象 |
| 消息编码器 | 出站 | MessageToMessageEncoder、StringEncoder、ProtobufEncoder | 业务对象 → 帧 |
| 整包编解码 | 双向 | MessageToMessageCodec、ByteToMessageCodec | 同时处理两个方向 |
| 长度补头 | 出站 | LengthFieldPrepender | 在消息前写入长度字段 |
ByteToMessageDecoder 的关键约定:
public class MyDecoder extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
if (in.readableBytes() < HEADER_LEN) {
return; // 数据不足,直接返回,由基类保留累积
}
in.markReaderIndex(); // 记住位置,便于回退
int len = in.readInt();
if (len < 0 || len > MAX_FRAME) {
throw new CorruptedFrameException("invalid frame length: " + len);
}
if (in.readableBytes() < len) {
in.resetReaderIndex(); // 数据不足,回退后等待下次
return;
}
byte[] body = new byte[len];
in.readBytes(body);
out.add(deserialize(body));
}
}
三个必须遵守的点:
- 数据不足时
return而不是抛异常,基类会把剩余字节保留到下次 markReaderIndex/resetReaderIndex配对使用,否则读掉的头字节无法恢复- 长度字段必须做边界校验,防止伪造的超大长度触发巨额内存分配
LengthFieldBasedFrameDecoder 的五个参数:
new LengthFieldBasedFrameDecoder(
maxFrameLength, // 单帧最大长度,超限抛 TooLongFrameException
lengthFieldOffset, // 长度字段的起始偏移
lengthFieldLength, // 长度字段本身占几个字节(1/2/3/4/8)
lengthAdjustment, // 长度字段的值需要加上多少才是消息体长度
initialBytesToStrip // 解码后从帧头剥离多少字节(通常等于偏移 + 长度字段长度)
);
序列化的技术选型(JSON、Protobuf、Kryo 等的对比)见 序列化与反序列化。
7.6 引导与线程模型配置
EventLoopGroup boss = new NioEventLoopGroup(1); // mainReactor
EventLoopGroup worker = new NioEventLoopGroup(); // subReactor 组
EventExecutorGroup business = new DefaultEventExecutorGroup(16); // 业务线程池
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(boss, worker)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 1024) // 作用于监听 socket
.childOption(ChannelOption.TCP_NODELAY, true) // 作用于每条接入的连接
.childOption(ChannelOption.SO_KEEPALIVE, true)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ch.pipeline()
.addLast(new IdleStateHandler(60, 30, 0))
.addLast(new LengthFieldBasedFrameDecoder(1024 * 1024, 0, 4, 0, 4))
.addLast(new LengthFieldPrepender(4))
.addLast(business, new BusinessHandler()); // 业务 handler 挂在业务线程组
}
});
ChannelFuture future = bootstrap.bind(8080).sync();
future.channel().closeFuture().sync();
要点:
option与childOption的作用对象不同。option作用于ServerSocketChannel(监听 socket),childOption作用于 accept 出来的每条SocketChanneladdLast(group, handler)把 handler 移出 IO 线程。这是避免阻塞 IO 线程的标准手段;代价是事件在 IO 线程与业务线程之间多了一次交接,handler 之间共享的状态以及"同 Channel 全程单线程"这一前提都需要重新确认- handler 顺序即处理顺序。入站按添加顺序、出站按相反顺序,因此
LengthFieldPrepender(补长度头)与解码器的位置需要对应设计
三、实现
1. 从 NIO 到框架
先看手写一个健壮 NIO 服务端需要处理哪些问题,才能理解框架的存在意义。
1.1 事件处理与业务解耦
单线程的 select 循环里,任何一次耗时的业务处理都会让其他所有连接等待。要解耦就必须把业务移交线程池,随即引入了一组新问题:提交什么(字节还是已解码的对象)、线程池队列满时怎么办、同一连接的任务如何保持顺序、业务线程回写 Channel 时如何与 selector 线程安全交接。
原生方案是"业务线程把结果封装成任务,通过 selector.wakeup() 唤醒 selector 线程再执行写操作",这个模式需要自行实现并保证线程安全。Netty 把它抽象成 EventLoop.execute() 与 ChannelFuture:从任意线程调用 channel.write() 都会被安全地投递到该 Channel 所属的 EventLoop。
1.2 半包处理
原生方案需要为每个 SelectionKey 挂一个累积缓冲区(作为 attachment),并在每次读取后做"尝试解码 → 保留剩余"的循环。缓冲区的大小管理、扩容策略、内存复用都要自己实现。忘记保留剩余数据就会丢消息,忘记限制长度就会 OOM。
Netty 把这件事抽象成 ByteToMessageDecoder 的"累积 + 循环 decode + 自动保留",并提供了 LengthFieldBasedFrameDecoder 等现成实现。
1.3 写未完成
原生方案需要实现"写队列 + OP_WRITE 注册/取消"的完整状态机。这部分最容易出现三个后果:丢数据(不处理部分写入)、CPU 空转(不取消 OP_WRITE)、内存泄漏(队列无上限)。
Netty 用 ChannelOutboundBuffer 统一管理待写数据,用 WriteBufferWaterMark 暴露可写性,用 ChannelWritabilityChanged 事件让应用感知背压。写队列有上限、可判断、可响应,这是原生 NIO 完全没有的能力。
1.4 空轮询 bug
这是 Java NIO 在 Linux 上的一个具体缺陷:在某些内核版本组合下,Selector.select() 会在没有任何事件的情况下立即返回(返回值为 0),导致事件循环变成忙等,单个 CPU 核心被占满。
Netty 的规避方式是统计空轮询次数:若 select 返回 0 且没有到期任务,累计 selectCnt;当计数超过阈值(默认 512)时,重建 Selector(把原 Selector 上所有 Channel 重新注册到新 Selector),并记录一次告警日志。这个阈值与行为可通过系统属性调整。
原生 NIO 若不做这层处理,就会在特定环境下遭遇无法解释的 CPU 100%。这是"知道 NIO 有坑"与"知道坑在哪里"之间的差距,也是框架价值的直接体现。
1.5 异常与关闭
原生方案需要在每个可能失败的分支上正确释放资源:read 返回 -1 时关闭并注销、异常时关闭并注销、register 失败时清理。任何一处遗漏都会表现为 fd 泄漏或 CLOSE_WAIT 堆积。
Netty 用 pipeline 的生命周期回调(handlerAdded / handlerRemoved / channelInactive)把"释放"绑定到事件上,配合引用计数保证 ByteBuf 的回收,把资源管理的正确性从"每个分支都要记得"变成"框架保证"。
1.6 框架解决的具体问题清单
| 原生 NIO 需要自己实现 | Netty 的对应抽象 |
|---|---|
| selector 事件循环与线程模型 | EventLoop / EventLoopGroup |
| 连接状态机与资源释放 | Channel 生命周期事件 |
| 半包累积与解码 | ByteToMessageDecoder、LengthFieldBasedFrameDecoder |
| 写未完成与写队列 | ChannelOutboundBuffer、ChannelFuture |
| 背压感知 | WriteBufferWaterMark、ChannelWritabilityChanged |
| 事件与业务解耦 | EventExecutorGroup、addLast(group, handler) |
| 缓冲区分配与复用 | ByteBuf、PooledByteBufAllocator |
| 空轮询 | selectCnt 计数 + Selector 重建 |
| 空闲检测 | IdleStateHandler |
| 跨线程写 Channel | 任务投递到 EventLoop |
2. Netty 服务端与客户端要点
2.1 线程模型配置
| 配置项 | 常用取值 | 说明 |
|---|---|---|
bossGroup 线程数 | 1 | accept 与注册,工作量小 |
workerGroup 线程数 | CPU × 2(默认) | IO 事件处理 |
| 业务线程组 | 视业务而定 | 阻塞调用(DB、RPC、文件)必须移出 IO 线程 |
| 定时任务线程组 | 可选 | 心跳、重连等定时逻辑 |
判断是否需要业务线程组的标准:handler 内是否存在可能超过毫秒级的阻塞调用。数据库查询、同步 HTTP 调用、文件读写、加解密大文件、Thread.sleep 都属于此类。
业务线程组的规模、队列与拒绝策略的选取,以及线程复用带来的线程本地变量与内存可见性问题,见 Java 并发编程。
高危:修改线程模型(增减 workerGroup 线程数、把 handler 移入或移出业务线程组)会改变同一 Channel 的事件执行线程,若 handler 内部持有可变状态且未做同步,改动后可能出现数据错乱或并发异常。影响范围:所有连接的请求处理路径,且表现为难以复现的偶发错误。回滚方式:恢复 NioEventLoopGroup 的线程数参数与 addLast 的重载形式,重启实例;变更前应确认所有 handler 是否持有跨事件的可变状态,并优先在预发环境验证。
2.2 编解码器组合
// 服务端 pipeline:入站从字节流到业务对象
pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(1024 * 1024, 0, 4, 0, 4));
pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));
pipeline.addLast("decoder", new MyMessageDecoder()); // 帧 → 业务对象
pipeline.addLast("encoder", new MyMessageEncoder()); // 业务对象 → 帧
pipeline.addLast("business", new BusinessHandler());
顺序规则:LengthFieldBasedFrameDecoder 必须在业务解码器之前(先有完整帧,才能反序列化);LengthFieldPrepender 必须在业务编码器之前添加(出站事件反向传播,最后添加的编码器最先执行,因此补长度头的编码器要放在业务编码器"之前"的位置,才能让它在业务编码器之后执行)。
实际配置时按"入站顺序 = 添加顺序,出站顺序 = 添加顺序的逆序"推导一遍,可以避免绝大多数顺序错误。
2.3 心跳与空闲检测
见第二部分 6.2 小节。工程上需要额外注意:
- 心跳报文应当有独立的消息类型,避免与业务消息混淆
- 心跳不应触发业务的幂等性或审计逻辑
- 读空闲阈值必须大于对端的写空闲间隔,两侧配置需要联合评审
2.4 连接超时与重连策略
连接超时:
Bootstrap bootstrap = new Bootstrap();
bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000); // 连接建立超时
CONNECT_TIMEOUT_MILLIS 只覆盖"三次握手"阶段,不覆盖连接建立之后的读写等待。读超时需要用 ReadTimeoutHandler 或 IdleStateHandler 单独配置。
重连策略:直接循环重连会在对端故障时形成重连风暴。正确做法是指数退避加随机抖动:
private void reconnect(Bootstrap bootstrap, EventLoopGroup group, int attempt) {
if (attempt > MAX_ATTEMPTS) {
return; // 超过上限,交人工介入
}
// 基础间隔按 2 的幂增长,并叠加随机抖动以打散重连时刻
long base = Math.min(MAX_BACKOFF_MS, INITIAL_BACKOFF_MS << attempt);
long delay = base / 2 + ThreadLocalRandom.current().nextLong(base / 2 + 1);
group.schedule(() -> bootstrap.connect(host, port).addListener(future -> {
if (future.isSuccess()) {
// 重连成功,重置 attempt 计数
} else {
reconnect(bootstrap, group, attempt + 1); // 失败则下一轮
}
}), delay, TimeUnit.MILLISECONDS);
}
设计要点:
- 退避间隔要有上限,否则长时间故障后首次重连的等待时间不可接受
- 必须叠加随机抖动,否则大量客户端会在同一时刻重连,把服务端的 SYN 队列打满
- 重连要在
EventLoop上调度(group.schedule),不要自己起Timer或线程 - 区分可重试与不可重试的错误。连接被拒绝、网络不可达可重试;认证失败、协议不兼容应立即停止并告警
2.5 异常处理与关闭顺序
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
if (cause instanceof IOException) {
// 对端关闭、连接重置等属正常现象,记录为调试级别
log.debug("io error, remote={}", ctx.channel().remoteAddress(), cause);
} else {
log.error("unexpected error, remote={}", ctx.channel().remoteAddress(), cause);
}
ctx.close(); // 关闭连接,释放资源
}
关闭顺序原则:
- handler 内关闭连接用
ctx.close()(从当前节点向上传播)而不是channel.close()(从头开始),避免重复触发链上已处理过的逻辑 - 应用退出时先关监听、再关连接、最后关线程组
- 所有关闭动作都应监听
ChannelFuture,确认完成后再进入下一步 handlerRemoved与channelInactive中释放自定义资源(连接池借出的对象、注册中心的条目、本地缓存)
2.6 依赖引入
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.115.Final</version>
</dependency>
生产环境通常按需引入 netty-transport、netty-codec、netty-handler 等更细的模块,以减少依赖体积与冲突面。使用前应确认版本与已有中间件客户端(如 Redis、MQ 客户端内置的 Netty)的版本一致,否则可能出现 NoSuchMethodError 类的运行时冲突。
3. 性能相关
3.1 TCP 参数与 Netty 参数
| 参数 | 作用 | 建议 |
|---|---|---|
SO_BACKLOG | 全连接队列长度(已完成三次握手、等待 accept 的连接) | 生效值是它与内核 net.core.somaxconn 的较小者;两者需同时调整 |
TCP_NODELAY | 关闭 Nagle 算法,小包立即发送 | 延迟敏感场景设为 true;纯大吞吐场景影响有限 |
SO_KEEPALIVE | 开启 TCP keepalive | 默认探测间隔 2 小时,对在线业务无实用价值,应用层心跳才是关键 |
SO_REUSEADDR | 允许绑定处于 TIME_WAIT 的地址 | 服务重启时避免"Address already in use" |
SO_RCVBUF / SO_SNDBUF | 单连接接收/发送缓冲区 | 显式设置会关闭内核自动调优,一般不设 |
WRITE_BUFFER_WATER_MARK | Netty 发送队列的高低水位 | 默认 32 KB / 64 KB;大消息场景需上调,否则频繁触发不可写 |
高危:调整内核网络参数(net.core.somaxconn、net.ipv4.tcp_rmem、net.ipv4.tcp_wmem)与在代码中显式设置 SO_RCVBUF / SO_SNDBUF,会直接影响所有连接的握手能力与吞吐表现。具体影响:somaxconn 调小会丢弃已完成握手的连接(客户端看到连接超时);tcp_rmem / tcp_wmem 调小会降低大带宽时延积链路的吞吐;显式设置 SO_RCVBUF 会关闭内核的接收缓冲自动调优(net.ipv4.tcp_moderate_rcvbuf),在长肥管道上可能显著降低吞吐。回滚方式:参数调整使用 sysctl -w 临时生效,重启即恢复;持久化配置写在 /etc/sysctl.d/ 下的独立文件中,回滚时删除该文件并执行 sysctl --system;代码层的 SO_RCVBUF / SO_SNDBUF 删除对应 option / childOption 行后重新发布即可。变更应逐个参数进行并配合压测对比。
同时需要注意:压测的环境差异会掩盖问题。本机回环(lo)没有真实的丢包与带宽限制,SO_BACKLOG、缓冲区大小、拥塞控制的价值在回环上都体现不出来。性能结论必须以带网络延迟与丢包的压测环境为准。
3.2 水位与可写性判断
WriteBufferWaterMark 决定"什么时候算写不进去":
bootstrap.childOption(ChannelOption.WRITE_BUFFER_WATER_MARK,
new WriteBufferWaterMark(32 * 1024, 64 * 1024));
语义:
- 待发字节数 低于低水位:
isWritable()返回true - 待发字节数 超过高水位:
isWritable()返回false,触发ChannelWritabilityChanged - 介于两者之间:保持上一次的状态(滞回设计,避免在边界反复抖动)
水位设置的经验:
- 默认值适合小消息、高并发的 RPC 场景
- 大消息(MB 级)场景必须上调,否则每条消息写入都会立刻超过高水位
- 高水位本质上就是"单连接的待发内存上限"。连接数乘以高水位即该配置下的最坏内存占用,需要与堆外内存预算一起核算
3.3 避免在 IO 线程做阻塞操作
EventLoop 线程被阻塞时,它管理的所有 Channel 都无法处理事件,包括心跳发送与超时关闭。影响范围随单个 EventLoop 上的连接数放大。
| 阻塞操作 | 替代方式 |
|---|---|
| 数据库查询 | 移入业务线程组;或改用异步驱动 |
| 同步 HTTP / RPC 调用 | 移入业务线程组;或改用异步客户端 |
| 文件读写 | 移入业务线程组;小文件可用 ChunkedWriteHandler |
| 大对象 JSON 序列化 | 移入业务线程组,或将编解码放到业务组 |
Thread.sleep / 线程 join | 改为 EventLoop.schedule |
获取 synchronized 锁 | 避免在 handler 内跨连接争抢同一把锁 |
| 日志写入(同步文件 appender) | 使用异步 appender |
一个可观测的判断方法:在压测中监控 EventLoop 的任务队列长度与单次 select 循环耗时,若耗时随 QPS 上升而线性增加,说明 IO 线程被占用过多。
4. 常见故障排查
4.1 连接数暴涨与句柄耗尽
现象:进程报 Too many open files、新连接被拒绝、/proc/PID/fd 数量接近 ulimit -n。
# 系统级连接统计
ss -s
# 按状态分组计数
ss -tan | awk 'NR>1 {print $1}' | sort | uniq -c | sort -rn
# 某进程的文件描述符数量
ls /proc/<pid>/fd | wc -l
# 当前进程的限制
cat /proc/<pid>/limits | grep -i 'open files'
按状态区分根因:
| 状态堆积 | 含义 | 处理方向 |
|---|---|---|
CLOSE_WAIT | 对端已发 FIN,本端应用未调用 close() 释放 fd | 应用侧资源释放缺陷:检查异常分支是否跳过了关闭逻辑;优先排查 try/finally 与 exceptionCaught |
TIME_WAIT | 本端主动关闭后的等待状态(2MSL) | 短连接过多:改用连接池/长连接;必要时调整 net.ipv4.tcp_tw_reuse |
SYN_RECV 堆积 | 半连接队列积压 | 可能是 SYN 洪水,或应用层 accept 速度跟不上(SO_BACKLOG 与 somaxconn 过小) |
ESTABLISHED 持续上涨 | 真实连接增长 | 确认是业务增长还是连接泄漏(同一客户端反复新建而未使用连接池) |
CLOSE_WAIT 与 TIME_WAIT 的完整诊断命令与处理手段见 Linux 网络 与 网络诊断与远程连接。
进程侧的句柄、连接池与线程栈证据如何结合判读,以及容器限额下的诊断顺序,见 Java 应用诊断与部署调优。
4.2 半包导致的解析错乱
现象:偶发的解码异常、业务字段错位、请求内容与预期不符;重启后短时间内正常。
排查步骤:
- 确认解码器配置。逐项核对长度字段的偏移、长度、是否需要加减补偿、剥离字节数;常见错误是长度字段的含义被误解(是"消息体长度"还是"含头总长度")
- 用
EmbeddedChannel做分片测试。把一条完整报文的字节数组按 1 字节、3 字节等不规则切分后逐段写入,验证解码结果:
EmbeddedChannel channel = new EmbeddedChannel(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4));
byte[] full = buildFrame(payload);
for (byte b : full) {
channel.writeInbound(Unpooled.wrappedBuffer(new byte[]{b})); // 逐字节注入
}
// 断言解出的消息与预期一致
- 抓包对照。用
tcpdump抓取通信两端,观察 TCP 分段的实际边界,确认问题出在协议设计还是解码实现
抓包与过滤表达式的用法见 网络诊断与远程连接。
4.3 写缓冲积压导致内存增长
现象:堆外内存或整体 RSS 持续上涨,堆内正常;GC 无明显收益。
排查步骤:
- 确认待发字节数。通过
ChannelOutboundBuffer的指标或自定义 handler 定期打印channel.bytesBeforeUnwritable()与isWritable()状态 - 观察可写性事件频率。
ChannelWritabilityChanged频繁触发说明水位设置不合理或对端读取慢 - 检查直接内存占用。
-XX:MaxDirectMemorySize的限制是否触及;Netty 的ByteBufAllocatorMetric可提供池化分配的用量 - 定位根因:对端读取慢(网络或对端处理能力)、业务写入速率超过网络出口带宽、单条消息过大导致水位频繁越界
处理方向:实现背压(暂停读上游)、上调水位并核算内存预算、压缩或分片大消息、检查是否存在"只写不判断可写性"的代码。
4.4 连接泄漏
现象:fd 数量与内存随运行时间单调增长,重启后归零。
定位手段:
| 手段 | 说明 |
|---|---|
ResourceLeakDetector 报告 | 检索日志中的 LEAK: 关键字,堆栈会指向创建 ByteBuf 的位置 |
| 连接计数监控 | 在 pipeline 首尾各加 handler,统计 channelActive / channelInactive 的差值,差值持续为正说明有连接未关闭 |
ChannelGroup | 把所有 Channel 加入 ChannelGroup,便于统计总数并在关闭时统一处理 |
| fd 与连接对应 | 用 lsof -p <pid> 对照 ss 的连接列表,找出"有 fd 但无对应连接"或长期空闲的连接 |
代码侧的常见成因:exceptionCaught 中未关闭 Channel、把 Channel 存入 Map 但关闭时未移除、使用自定义线程池持有 Channel 引用导致无法回收、连接池归还逻辑遗漏。
4.5 网络抖动下的重连风暴
现象:网络抖动或对端重启后,客户端实例在同一时刻集中重连,服务端 SYN 队列被打满,新连接被丢弃,业务恢复时间远长于故障时长。
排查与处理:
- 确认重连是否退避。检索重连逻辑是否存在固定间隔的循环重试
- 确认是否有随机抖动。只有指数退避而没有抖动时,同一批启动的客户端仍会同步重连
- 服务端侧确认队列状况:
ss -s观察 SYN 队列、netstat -s | grep -i listen观察队列溢出计数 - 处理方向:客户端指数退避 + 抖动;服务端上调
SO_BACKLOG与somaxconn(需一并评估内存);引入连接池与预热;对重连速率做客户端侧限流
4.6 故障定位命令速查
# 连接状态总览
ss -s
ss -tan state established | wc -l
ss -tan state close-wait | wc -l
ss -tan state time-wait | wc -l
# 端口监听与队列
ss -lnt
# 抓包:看三次握手、重传、窗口
tcpdump -i eth0 -nn 'tcp port 8080 and (tcp[tcpflags] & (tcp-syn|tcp-fin|tcp-rst)) != 0'
# 重传与队列溢出统计
netstat -s | grep -i -E 'retrans|overflow|listen'
# 文件描述符与连接对应
lsof -p <pid> -a -i
高危:使用 ss -K 强制关闭连接,或通过 kill -9 终止服务进程,会立即中断在途请求并让对端收到 RST(而非正常关闭),对端可能表现为"连接被重置"的批量报错。影响范围:被中断连接上的全部在途请求。回滚方式:无法回滚已中断的连接,只能由调用方重试;建议先摘除流量(从负载均衡下线)再执行强制操作,或在低峰期进行,并优先使用优雅关闭路径(关闭监听 → 等在途完成 → 释放资源)。
5. 技术选型
5.1 Netty 与 Servlet 容器
| 维度 | Netty | Servlet 容器(Tomcat / Jetty) |
|---|---|---|
| 协议 | 任意(TCP/UDP/自定义二进制) | HTTP 为主,WebSocket 需容器支持 |
| 编程模型 | 事件驱动 + handler 链 | 请求-响应方法调用,同步阻塞 |
| 连接模型 | 长连接、双向推送天然支持 | HTTP/1.1 以短连接为主,长连接需额外处理 |
| 线程成本 | 少量 IO 线程承载大量连接 | 每请求占用一个工作线程(虚拟线程可缓解) |
| 生态 | 需自行实现协议与治理 | 成熟(MVC、Filter、Session、安全框架) |
| 调试与排查 | 需理解事件模型,堆栈不直观 | 堆栈清晰,问题定位直观 |
| 适用 | IM、游戏、IoT、RPC 框架、MQ broker、网关 | 业务 API、Web 应用、后台管理系统 |
判断标准可以归纳为一句话:协议是不是 HTTP、连接是不是短连接、团队是否具备长连接运维经验。三者都偏向传统一侧时,Servlet 容器是更稳的选择。
5.2 WebFlux 的边界
Spring WebFlux 是 HTTP 场景下的响应式实现,运行在 Reactor Netty 之上(即底层仍是 Netty),对外暴露 Mono / Flux 数据流。
| 维度 | Spring MVC | Spring WebFlux |
|---|---|---|
| 编程模型 | 命令式,顺序执行 | 声明式,数据流组合 |
| 线程模型 | 每请求一个工作线程 | 少量事件循环线程 |
| 阻塞依赖 | 全部可用(JDBC、同步 HTTP 客户端) | 需使用响应式驱动,阻塞调用会破坏模型 |
| 适用场景 | CPU 密集、依赖阻塞驱动、逻辑复杂 | IO 密集、高并发、流式响应(SSE) |
| 调试难度 | 低 | 高(堆栈被响应式管道截断) |
WebFlux 的价值只在IO 密集且并发量高,且链路上下游都能提供响应式驱动时才能体现。若链路中存在 JDBC、同步 RPC 等阻塞依赖,把它们放进事件循环线程反而会拖垮整个服务。相关背景(Servlet 规范的演进、非阻塞 IO 接口、WebFlux 的定位)见 Java Web。
5.3 何时不需要 Netty
| 场景 | 更合适的选择 |
|---|---|
| 普通 HTTP 业务 API | Servlet 容器 + Spring MVC,框架与生态成本最低 |
| 需要 HTTP 语义但并发较高 | Spring WebFlux(底层依然用 Netty,但不必自行管理) |
| 并发量不高、连接数在数百以内 | 直接用 BIO + 线程池,代码量与排查成本最低 |
| 需要内置的 RPC 能力 | 直接用成熟的 RPC 框架,不必在 Netty 上自研协议栈 |
| 只需定时调用外部 HTTP 接口 | 普通 HTTP 客户端 + 连接池 |
| 需要极低延迟的 IPC(同机) | 共享内存、Unix 域套接字(见 网络编程是什么 的边界判定) |
一个务实的判断顺序:先确认协议与连接形态是否真的需要自定义(若只用 HTTP,多数情况下不需要 Netty);再确认并发规模是否真的超过线程池模型的承载能力;最后确认团队是否具备维护长连接与协议栈的能力。
值得补充的是 Java 21 的虚拟线程:它把阻塞式调用的线程成本降到很低,使得"一请求一线程"的同步模型在更高并发下依然可用。这意味着过去"为了省线程而转向异步框架"的许多场景,可以重新选择更易调试的同步模型。虚拟线程与平台线程在栈内存、调度、阻塞卸载上的差别见 Java 完整手册 第九章;并发模型的底层机制见 Java 并发编程。
5.4 Netty 内部还需要做的选择
| 决策点 | 选项 | 建议 |
|---|---|---|
| 传输实现 | NIO / epoll(原生)/ kqueue | Linux 上用 EpollEventLoopGroup 可获得更完整的边沿触发与更多配置项;NIO 是跨平台默认值;AIO 不建议 |
| 分配器 | 池化 / 非池化 | 默认池化;只有在缓冲区生命周期难以控制的场景才考虑非池化 |
| 缓冲区类型 | 堆 / 直接 | 网络 IO 用直接缓冲区(默认);需要频繁按字节访问时注意直接缓冲区的访问开销 |
| 内存泄漏检测等级 | SIMPLE / ADVANCED / PARANOID | 生产用默认 SIMPLE,排查期短时上调 |
| 业务线程组 | 用 / 不用 | handler 内有阻塞调用则必须使用 |
| 编解码器 | 长度字段 / 分隔符 / 定长 | 二进制协议优先长度字段;文本协议用分隔符并设置最大帧长 |
四、总结
网络编程的 IO 模型问题,起点是一个资源矛盾:"一连接一线程"把线程数与连接数绑在一起,而线程是昂贵的。解决思路是把"等待就绪"从每个线程中抽出来交给少量的多路复用器,从而让线程只用于真正有数据要处理的连接。这条线索贯穿了本文的全部内容。
原理层面的关键结论:
- 五类 IO 模型的差别只在两个阶段是否阻塞。前四类都阻塞在"内核缓冲区 → 用户缓冲区"的拷贝上,只有异步 IO 两个阶段都不阻塞。
select/epoll解决的是"等哪个 fd",不是"拷贝怎么省"。Linux 上 JDK 的 AIO 由 epoll + 线程池模拟,因此没有真实的线程成本优势。 select/poll/epoll的差距在于复杂度与调用方式。前两者每次都需传入并扫描全部 fd(O(n)),epoll注册一次、只取就绪项,因此高并发下的可扩展性完全不同;边沿触发进一步减少了通知次数,代价是要求应用一次读干净。- NIO 三件套的语义集中在
Buffer的索引与Selector的事件上。flip/clear/compact的区别决定了数据是否被丢弃;OP_WRITE只能临时注册、selectedKeys必须手工移除,这两点决定了事件循环的正确性。 - 直接缓冲区换来的是少一次拷贝,代价是昂贵的分配与不受
-Xmx约束的内存,因此必须复用并对-XX:MaxDirectMemorySize做显式预算。 - 零拷贝的本质是让 CPU 不参与数据搬运。
read+write是 4 次拷贝、4 次切换;mmap省掉一次 CPU 拷贝;sendfile把切换降到 2 次、拷贝降到 1 次甚至 0 次(SG-DMA),但不能修改数据,因此启用 TLS 后失效。 - 粘包与半包是两个方向的问题。读侧要解决"字节流没有边界",写侧要解决"一次没写完"。协议设计上定长、分隔符、长度字段三种方案各有适用面,其中长度字段最通用,但必须做长度校验并提供累积缓冲。
- 背压的关键是把压力传回源头,而不是丢弃或无限缓冲;心跳的关键是"发探测"与"判超时"必须成对;优雅关闭的关键是"先停止接受、再等在途、最后释放"的顺序。
- Netty 的价值是把 NIO 的正确性负担变成框架契约:
EventLoop提供同 Channel 串行,ByteToMessageDecoder处理半包,ChannelOutboundBuffer与水位暴露写未完成与背压,ByteBuf的引用计数管理生命周期,selectCnt计数规避空轮询。
工程层面的结论:
- 线程模型的底线是 IO 线程不做阻塞操作。任何耗时调用都应移到业务线程组;同时要记住移出之后"同 Channel 串行"的保证随之转移,handler 内的可变状态需要重新审视。
- 参数调整需要区分层次。
SO_BACKLOG与somaxconn取小者生效,必须成对配置;显式设置SO_RCVBUF/SO_SNDBUF会关闭内核自动调优,一般不应触碰;TCP_NODELAY是延迟敏感场景的常规选项;WRITE_BUFFER_WATER_MARK是应用层背压的开关。 - 故障排查沿着"连接状态 → 缓冲区 → 资源生命周期"三条线展开。
CLOSE_WAIT堆积指向应用未关闭连接,TIME_WAIT过多指向短连接,写缓冲积压指向背压缺失,fd 与内存的单调增长指向连接或缓冲区泄漏,重连风暴指向缺少退避与抖动。 - 选型应从协议与连接形态出发,而不是从框架热度出发。只用 HTTP、连接数可控、团队不擅长长连接运维时,Servlet 容器是成本最低的选择;WebFlux 只在 IO 密集且上下游都提供响应式驱动时才有价值;虚拟线程的成熟让许多原本被迫异步化的场景可以回到同步模型。
IO 模型的演进方向始终是"把等待从业务线程中剥离"。理解了这一点,
epoll、Reactor、Netty 的EventLoop、sendfile、背压水位这些看似分散的机制,就都能落到同一条主线上。