内容总览

Java IO 模型与 Netty 思维导图

一、起源:阻塞式 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. 两个方向的阻塞

上面的模型有两处阻塞:

  1. accept() 阻塞。没有新连接时,接受连接的主线程停在 accept() 上。这一处阻塞可以通过单独的接受线程缓解,不是主要矛盾。
  2. read() 阻塞。这是核心矛盾。数据未到达时,处理该连接的线程只能停在 read() 上,直到对端发来数据或关闭连接。

阻塞本身不是问题,用独立线程去承担阻塞才是问题。每个连接独占一个线程,意味着:

资源 成本
线程栈内存 每个平台线程默认保留 512 KB~1 MB 的栈空间(-Xss 可调),1 万个连接即 5~10 GB
线程对象与内核结构 每个线程在 JVM 与内核中各有一份元数据(栈、任务结构体、寄存器上下文)
上下文切换 线程数超过 CPU 核数后,切换到被唤醒的线程需要保存/恢复寄存器与刷新 TLB、缓存,单次约数微秒,且缓存命中率下降
调度开销 大量线程同时就绪时,调度器本身的运行时间不可忽略

而真实业务中,同一时刻只有少量连接是真的"有数据可处理",其余线程都停在 read() 上等待。线程资源被大量闲置,却又真实占用内存并参与调度。

这就是 C10K 问题的内核:不是操作系统做不了 1 万个连接,而是"一连接一线程"的组织方式让连接数与线程数绑定在一起。

3. 需要新的 IO 组织方式

如果能让少量线程同时"看住"大量连接,只在连接真正就绪时才去处理,线程数就与连接数解耦了。这一思路的实现依赖三个前置条件:

  1. 操作系统提供"等待多个 fd 就绪"的能力——即 IO 多路复用(select / poll / epoll)
  2. fd 可以工作在非阻塞模式——读不到数据时立刻返回,而不是挂起线程
  3. 应用层的读写接口能从"流"改为"缓冲区 + 事件回调"——即 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 的两项能力是关键:

  1. 注册与等待分离。fd 通过 epoll_ctl 加入内核的红黑树,只需注册一次;epoll_wait 无需重复拷贝整个集合,扫描的对象是就绪链表而非全部 fd。
  2. 边沿触发(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);
        }
    }
}

两个必须遵守的细节:

  1. it.remove() 不能省略。selectedKeys() 返回的集合由 Selector 维护,不会在 select() 时自动清空。不移除会导致同一个 key 被反复处理。
  2. 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 三个子问题

处理粘包需要同时解决三件事:

  1. 如何确定消息边界(协议设计)
  2. 如何在数据不足时缓存并等待(读缓冲管理)
  3. 如何在写出时处理"没写完"(写缓冲管理)

第 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,本身是一个单线程执行器,同时持有一个 Selector
  • EventLoopGroup 是 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 的方向)传播

两个必须注意的约束:

  1. @Sharable 与无状态。handler 默认每个 Channel 独享一个实例;若要复用(@Sharable),必须保证无状态,否则会串数据。
  2. 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 出来的每条 SocketChannel
  • addLast(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();                                     // 关闭连接,释放资源
}

关闭顺序原则:

  1. handler 内关闭连接用 ctx.close()(从当前节点向上传播)而不是 channel.close()(从头开始),避免重复触发链上已处理过的逻辑
  2. 应用退出时先关监听、再关连接、最后关线程组
  3. 所有关闭动作都应监听 ChannelFuture,确认完成后再进入下一步
  4. 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 半包导致的解析错乱

现象:偶发的解码异常、业务字段错位、请求内容与预期不符;重启后短时间内正常。

排查步骤:

  1. 确认解码器配置。逐项核对长度字段的偏移、长度、是否需要加减补偿、剥离字节数;常见错误是长度字段的含义被误解(是"消息体长度"还是"含头总长度")
  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}));   // 逐字节注入
}
// 断言解出的消息与预期一致
  1. 抓包对照。用 tcpdump 抓取通信两端,观察 TCP 分段的实际边界,确认问题出在协议设计还是解码实现

抓包与过滤表达式的用法见 网络诊断与远程连接。

4.3 写缓冲积压导致内存增长

现象:堆外内存或整体 RSS 持续上涨,堆内正常;GC 无明显收益。

排查步骤:

  1. 确认待发字节数。通过 ChannelOutboundBuffer 的指标或自定义 handler 定期打印 channel.bytesBeforeUnwritable() 与 isWritable() 状态
  2. 观察可写性事件频率。ChannelWritabilityChanged 频繁触发说明水位设置不合理或对端读取慢
  3. 检查直接内存占用。-XX:MaxDirectMemorySize 的限制是否触及;Netty 的 ByteBufAllocatorMetric 可提供池化分配的用量
  4. 定位根因:对端读取慢(网络或对端处理能力)、业务写入速率超过网络出口带宽、单条消息过大导致水位频繁越界

处理方向:实现背压(暂停读上游)、上调水位并核算内存预算、压缩或分片大消息、检查是否存在"只写不判断可写性"的代码。

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 队列被打满,新连接被丢弃,业务恢复时间远长于故障时长。

排查与处理:

  1. 确认重连是否退避。检索重连逻辑是否存在固定间隔的循环重试
  2. 确认是否有随机抖动。只有指数退避而没有抖动时,同一批启动的客户端仍会同步重连
  3. 服务端侧确认队列状况:ss -s 观察 SYN 队列、netstat -s | grep -i listen 观察队列溢出计数
  4. 处理方向:客户端指数退避 + 抖动;服务端上调 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、背压水位这些看似分散的机制,就都能落到同一条主线上。