04.1.4.1 NIO 与 Netty 核心机制
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.1 Java / 04.1.4 NIO 与 Netty
覆盖范围
- BIO / NIO / AIO 三种 IO 模型
- Channel、Buffer、Selector 三大组件
- Reactor 模式与 Netty 线程模型
- ByteBuf 与零拷贝
- 粘包拆包与解码器
- 自定义协议编解码
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 04.1.4.1-001 | BIO NIO AIO 区别 | 进阶 | ★★★★★ |
| 04.1.4.1-002 | Selector 多路复用原理 | 高级 | ★★★★★ |
| 04.1.4.1-003 | Reactor 模式三种形态 | 高级 | ★★★★☆ |
| 04.1.4.1-004 | Netty 零拷贝是什么 | 高级 | ★★★★☆ |
| 04.1.4.1-005 | ByteBuf 比 NIO ByteBuffer 好在哪 | 进阶 | ★★★★☆ |
| 04.1.4.1-006 | 粘包拆包原因与解决 | 进阶 | ★★★★★ |
| 04.1.4.1-007 | Netty 的 EventLoop 模型 | 高级 | ★★★★☆ |
| 04.1.4.1-008 | LengthFieldBasedFrameDecoder 用法 | 进阶 | ★★★★☆ |
04.1.4.1-001 BIO、NIO、AIO 有什么区别?
频率 ★★★★★ | 难度 进阶
一句话结论
BIO 是同步阻塞,一个连接一个线程,连接多了线程不够用;NIO 是同步非阻塞,一个线程通过 Selector 管理多个连接,事件驱动;AIO 是异步非阻塞,操作系统完成 IO 后回调通知,Linux 上 AIO 实现不成熟,实际用得少。
概念解释
- BIO(Blocking IO):同步阻塞,连接来了就开一个线程处理,线程在 read/write 时阻塞等待。
- NIO(Non-blocking IO):同步非阻塞,一个线程通过 Selector 轮询多个连接的事件,有事件才处理。
- AIO(Asynchronous IO):异步非阻塞,应用发起 IO 请求后立刻返回,操作系统完成数据拷贝后回调通知应用。
原理流程
- BIO:每来一个连接,服务端开一个线程处理,线程在 read() 时阻塞,直到数据到达。
- NIO:所有连接注册到 Selector,一个线程轮询 Selector,发现哪个连接有读事件,就处理哪个连接。
- AIO:应用调用 read 时告诉操作系统缓冲区位置,操作系统把数据读进缓冲区后,回调通知应用。
代码 / 示例
// BIO 示例:一个连接一个线程
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
Socket socket = serverSocket.accept(); // 阻塞等待连接
new Thread(() -> {
try {
InputStream in = socket.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf); // 阻塞等待数据
// 处理数据
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
// NIO 示例:单线程管理多个连接
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select(); // 阻塞等待事件
Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isAcceptable()) {
// 处理新连接
} else if (key.isReadable()) {
// 处理读事件
}
}
}
常见误区
- 误区:NIO 就是非阻塞?正解:NIO 是同步非阻塞,线程还是要轮询 Selector 拿事件;AIO 才是真正异步,操作系统做完 IO 才通知你。
- 误区:Linux 上 AIO 很好用?正解:Linux 的 AIO(io_uring 之前)实现很受限,磁盘 IO 支持不好,网络 IO 基本没人用,Netty 也是用 NIO 模型。
追问 / 延伸
- 为什么 Netty 用 NIO 不用 AIO?答:Linux 上 AIO 实现不成熟,NIO 的 Reactor 模型性能已经足够好,且跨平台一致。
- 什么是同步和异步?答:同步是你自己去等结果,异步是别人做完了通知你。
04.1.4.1-002 Selector 多路复用的原理是什么?
频率 ★★★★★ | 难度 高级
一句话结论
Selector 底层是操作系统的 epoll(Linux)/ kqueue(BSD)/ select(跨平台),一个线程可以同时监听多个文件描述符的事件,有事件发生时通知线程,避免一个连接一个线程的开销。
概念解释
- Selector:Java NIO 的多路复用器,底层封装了操作系统的 select/poll/epoll。
- Channel:网络连接,对应操作系统的文件描述符 fd。
- SelectionKey:Channel 注册到 Selector 后返回的句柄,表示监听哪些事件(读、写、连接、接受)。
- epoll:Linux 2.6 引入的高性能多路复用机制,比 select/poll 快,因为不需要每次都拷贝全部 fd 列表到内核。
原理流程
- 把所有连接的 Channel 注册到 Selector,告诉 Selector 关心哪些事件。
- 线程调用 selector.select(),阻塞在操作系统层面。
- 某个连接有数据可读时,操作系统把这个 fd 放到就绪列表。
- select() 返回,线程拿到就绪的 Channel 列表,逐个处理。
- epoll 的优势:注册时把 fd 放到内核的红黑树里,有事件时直接从就绪链表拿,不用遍历全部 fd。
代码 / 示例
Selector selector = Selector.open();
// 服务端 Channel 注册接受连接事件
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
// 客户端连接注册读事件
SocketChannel clientChannel = serverChannel.accept();
clientChannel.configureBlocking(false);
clientChannel.register(selector, SelectionKey.OP_READ);
// 事件循环
while (true) {
selector.select(); // 阻塞等待事件
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> it = keys.iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
it.remove(); // 处理完要移除
if (key.isAcceptable()) {
// 新连接
} else if (key.isReadable()) {
// 读数据
}
}
}
常见误区
- 误区:Selector 是 Java 自己实现的?正解:Selector 底层是操作系统的多路复用系统调用,Java 只是封装了一下。
- 误区:select() 是忙轮询?正解:select() 会阻塞,没有事件时线程挂起,有事件才唤醒。
追问 / 延伸
- select、poll、epoll 有什么区别?答:select 有 fd 数量限制(1024),每次都要拷贝全部 fd 到内核;poll 没有数量限制但还是要遍历;epoll 用红黑树存 fd,事件就绪直接拿,O(1)。
- 什么是水平触发和边缘触发?答:水平触发(LT)只要 fd 可读就一直通知;边缘触发(ET)只在状态变化时通知一次,要一次读完。
04.1.4.1-003 Reactor 模式有哪几种形态?
频率 ★★★★☆ | 难度 高级
一句话结论
Reactor 模式分三种:单 Reactor 单线程(所有事一个线程干)、单 Reactor 多线程(IO 一个线程,业务线程池处理)、主从 Reactor 多线程(主 Reactor 接连接,从 Reactor 处理 IO),Netty 默认是主从 Reactor 多线程。
概念解释
- Reactor:事件分发器,负责监听事件、分发到对应的处理器。
- 单 Reactor 单线程:一个线程既接连接、又读数据、又处理业务,简单但性能差。
- 单 Reactor 多线程:Reactor 线程只做 IO,业务处理交给线程池。
- 主从 Reactor 多线程:主 Reactor 只接新连接,接完交给从 Reactor 处理这个连接的 IO。
原理流程
- 单 Reactor 单线程:一个线程跑 Selector,接连接、读数据、写数据、业务逻辑全在这个线程。
- 单 Reactor 多线程:Reactor 线程负责读数据,读完丢给业务线程池处理,写完再丢回 Reactor 线程写。
- 主从 Reactor:主 Reactor(bossGroup)只负责 accept 新连接,接完把这个 SocketChannel 注册到从 Reactor(workerGroup),从 Reactor 负责这个连接的所有读写事件。
代码 / 示例
// Netty 的主从 Reactor 模型
EventLoopGroup bossGroup = new NioEventLoopGroup(1); // 主 Reactor,1 个线程
EventLoopGroup workerGroup = new NioEventLoopGroup(); // 从 Reactor,默认 CPU*2 个线程
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ch.pipeline().addLast(new MyHandler());
}
});
// bossGroup 只负责 accept 新连接
// workerGroup 负责每个连接的读写和业务处理
常见误区
- 误区:Netty 的 bossGroup 和 workerGroup 线程数一样?正解:bossGroup 一般 1 个线程就够了,因为 accept 很快;workerGroup 是 CPU 核心数 * 2。
- 误区:业务逻辑也在 EventLoop 线程里跑?正解:如果业务逻辑很耗时,要丢到业务线程池,否则会阻塞这个 EventLoop 上的其他连接。
追问 / 延伸
- 为什么主从 Reactor 性能好?答:主 Reactor 只做轻量的 accept,从 Reactor 做 IO,互不干扰;多个从 Reactor 并行处理连接,充分利用多核。
- 什么是 EventLoop?答:EventLoop 是一个线程,绑定了一个 Selector,所有注册到这个 Selector 的 Channel 的事件都在这个线程处理。
04.1.4.1-004 Netty 的零拷贝是什么?和操作系统的零拷贝有什么区别?
频率 ★★★★☆ | 难度 高级
一句话结论
Netty 的零拷贝是用户态的优化:CompositeByteBuf 把多个 Buffer 合成一个逻辑上的 Buffer,不用真正拷贝;DirectBuffer 用堆外内存,减少一次内核态到用户态的拷贝;操作系统的零拷贝是 sendfile,把磁盘数据直接从内核空间发到网卡,不经过用户态。
概念解释
- Netty 零拷贝(用户态):
- CompositeByteBuf:把两个或多个 ByteBuf 合成一个逻辑上的 ByteBuf,不真正拷贝数据。
- slice():把一个 ByteBuf 切成多个段,共享同一块内存,不拷贝。
- DirectBuffer:用堆外内存,Socket 读写时少一次从堆内到堆外的拷贝。
- FileRegion:用 sendfile 传输文件。
- 操作系统零拷贝(内核态):
- sendfile:数据从磁盘读进内核缓冲区,直接送到网卡,不经过用户态。
原理流程
- 传统的 read + write:磁盘 → 内核缓冲区 → 用户缓冲区 → Socket 缓冲区 → 网卡,四次拷贝。
- sendfile:磁盘 → 内核缓冲区 → 网卡,两次拷贝,数据不经过用户态。
- Netty 的 CompositeByteBuf:比如协议头 + 协议体,传统做法是把两个数组合并成一个大数组再发;CompositeByteBuf 只是逻辑上把两个 Buffer 当成一个,真正发送时分别发,不拷贝。
代码 / 示例
// CompositeByteBuf:把两个 ByteBuf 合成一个,不拷贝
ByteBuf header = Unpooled.buffer(10);
ByteBuf body = Unpooled.buffer(100);
CompositeByteBuf message = Unpooled.compositeBuffer();
message.addComponents(true, header, body);
// 逻辑上 message 是一个完整的 Buffer,实际内存是两块,没有拷贝
// slice:把一个大 Buffer 切成两段,共享内存
ByteBuf bigBuffer = Unpooled.buffer(200);
ByteBuf part1 = bigBuffer.slice(0, 100);
ByteBuf part2 = bigBuffer.slice(100, 100);
// part1 和 part2 和 bigBuffer 共享同一块内存,不拷贝
// FileRegion:用 sendfile 传文件
RandomAccessFile file = new RandomAccessFile("video.mp4", "r");
FileRegion region = new DefaultFileRegion(file.getChannel(), 0, file.length());
channel.writeAndFlush(region);
// 底层用 sendfile,不经过用户态
常见误区
- 误区:Netty 的零拷贝和操作系统的零拷贝是一回事?正解:Netty 的零拷贝是用户态的优化,减少用户态内部的拷贝;操作系统的零拷贝是内核态的优化,减少内核到用户态的拷贝。
- 误区:零拷贝就是完全不拷贝?正解:零拷贝是减少不必要的拷贝,不是完全没有拷贝,磁盘到内核缓冲区还是要拷贝。
追问 / 延伸
- 什么是 DirectBuffer?答:堆外内存,不在 JVM 堆里,GC 不管;Socket 读写时直接用,少一次从堆内到堆外的拷贝。
- 为什么 DirectBuffer 少一次拷贝?答:JVM 堆内内存可能被 GC 移动,所以 Socket 读写时要先把堆内数据拷贝到堆外临时缓冲区,再发给内核;DirectBuffer 本身就在堆外,直接用。
04.1.4.1-005 ByteBuf 比 NIO 的 ByteBuffer 好在哪?
频率 ★★★★☆ | 难度 进阶
一句话结论
ByteBuffer 只有一个 position/limit/capacity 指针,读写切换要 flip(),容易搞混;ByteBuf 有两个指针(readerIndex 和 writerIndex),读写不用切换,支持动态扩展、池化、零拷贝切片。
概念解释
- ByteBuffer:NIO 的缓冲区,只有一个指针,读之前要 flip(),写完要 clear(),容易出错。
- ByteBuf:Netty 的缓冲区,读指针和写指针分开,不用 flip。
- ByteBuf 支持池化:从池里拿 Buffer,用完还回去,减少 GC。
- ByteBuf 支持自动扩展:写满了自动扩容,不用手动检查。
原理流程
- ByteBuffer:写数据时 position 往后移,读完要 flip(),把 position 切到 0,limit 设成原来的 position。
- ByteBuf:writerIndex 指向写的位置,readerIndex 指向读的位置,写的时候 writerIndex 往后移,读的时候 readerIndex 往后移,互不干扰。
- ByteBuf 写满了,自动扩容,不用像 ByteBuffer 那样手动申请新 Buffer 再拷贝。
代码 / 示例
// ByteBuffer 的麻烦写法
ByteBuffer buf = ByteBuffer.allocate(48);
buf.putInt(1);
buf.putInt(2);
buf.flip(); // 切到读模式,很容易忘
int a = buf.getInt();
int b = buf.getInt();
buf.clear(); // 切回写模式
// ByteBuf 的简单写法
ByteBuf buf = Unpooled.buffer(48);
buf.writeInt(1);
buf.writeInt(2);
// 不用 flip,直接读
int a = buf.readInt();
int b = buf.readInt();
// 读完了继续写,不用 clear
buf.writeInt(3);
常见误区
- 误区:ByteBuf 就是 ByteBuffer 的包装?正解:ByteBuf 是重新设计的,解决了 ByteBuffer 很多设计缺陷。
- 误区:ByteBuf 要手动释放?正解:Netty 的池化 ByteBuf 要手动 release(),否则内存泄漏;Netty 有引用计数,自动管理。
追问 / 延伸
- 什么是池化 ByteBuf?答:Netty 4 之后引入的,从一个 Buffer 池里拿,用完还回去,减少分配和 GC 开销。
- 什么是 CompositeByteBuf?答:把多个 ByteBuf 合成一个逻辑上的 Buffer,不拷贝数据,是零拷贝的一种实现。
04.1.4.1-006 粘包拆包是什么?怎么解决?
频率 ★★★★★ | 难度 进阶
一句话结论
TCP 是流协议,没有消息边界,发送方发的多个包可能被粘在一起(粘包),一个大包可能被拆成多个(拆包);解决方法是在应用层定义消息边界:固定长度、特殊分隔符、或者长度字段 + 内容。
概念解释
- 粘包:发送方发了两个包 P1、P2,接收方一次读到了 P1P2 连在一起。
- 拆包:发送方发了一个大包 P,接收方分两次才读到 P1、P2。
- 原因:TCP 是面向流的,只保证字节顺序,不保证消息边界;Nagle 算法会把小包合并发送,MSS(最大分段大小)会把大包拆分。
原理流程
- 发送方调用 send(P1)、send(P2),TCP 可能把两个包合并成一个发出去。
- 接收方 recv() 一次读到 P1P2,不知道哪里是 P1 的结尾。
- 或者发送方发了一个 1000 字节的包,MSS 是 1460 但 MTU 限制,拆成两个包发。
- 接收方第一次只读到 500 字节,不是完整的消息。
代码 / 示例
// 解决方案一:固定长度,每个消息 1024 字节
public class FixedLengthDecoder extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
while (in.readableBytes() >= 1024) {
ByteBuf message = in.readBytes(1024);
out.add(message);
}
}
}
// 解决方案二:特殊分隔符,比如 \r\n
// Netty 内置 DelimiterBasedFrameDecoder
ByteBuf delimiter = Unpooled.copiedBuffer("\r\n".getBytes());
ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, delimiter));
// 解决方案三:长度字段 + 内容(最常用)
// Netty 内置 LengthFieldBasedFrameDecoder
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(
1024 * 1024, // 最大长度
0, // 长度字段偏移量
4, // 长度字段长度(4 字节 int)
0, // 长度字段补偿值
4 // 跳过的字节数(长度字段本身)
));
常见误区
- 误区:UDP 会粘包吗?正解:UDP 是面向消息的,每个包是独立的,不会粘包。
- 误区:粘包是 TCP 的 bug?正解:不是 bug,是 TCP 的设计,它就是流协议,应用层自己定义消息边界。
追问 / 延伸
- 什么是 Nagle 算法?答:TCP 为了提高效率,把小的数据包合并起来一起发,会增加延迟但减少包数;可以用 TCP_NODELAY 关闭。
- 常用的消息格式是什么?答:魔数 + 版本 + 消息类型 + 长度 + 消息体,类似 HTTP 协议头。
04.1.4.1-007 Netty 的 EventLoop 模型是什么?
频率 ★★★★☆ | 难度 高级
一句话结论
EventLoop 是一个线程,绑定一个 Selector,所有注册到这个 Selector 的 Channel 的 IO 事件都在这个线程处理;一个 EventLoop 可以处理多个 Channel,一个 Channel 从头到尾只绑定一个 EventLoop,保证线程安全。
概念解释
- EventLoop:事件循环,一个线程跑一个死循环,不断处理 Selector 上的事件。
- EventLoopGroup:一组 EventLoop,默认数量是 CPU 核心数 * 2。
- Channel 绑定:一个 Channel 在创建时分配到一个 EventLoop,之后所有这个 Channel 的事件都在这个 EventLoop 线程处理。
- 好处:同一个 Channel 的所有操作都在同一个线程,不用加锁,线程安全。
原理流程
- 客户端连接上来,ServerBootstrap 从 workerGroup 里选一个 EventLoop。
- 把这个 SocketChannel 注册到这个 EventLoop 的 Selector。
- 之后这个连接的所有读、写、事件回调,都在这个 EventLoop 线程执行。
- 业务代码如果耗时,要丢到业务线程池,否则会阻塞这个 EventLoop 上的其他连接。
代码 / 示例
// 业务耗时操作不要直接在 ChannelHandler 里做
public class MyBusinessHandler extends SimpleChannelInboundHandler<String> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) {
// 错误:直接在 EventLoop 线程里做耗时操作
// String result = callRemoteService(msg); // 耗时 100ms
// ctx.writeAndFlush(result);
// 正确:丢到业务线程池
businessExecutor.submit(() -> {
String result = callRemoteService(msg); // 耗时 100ms
ctx.writeAndFlush(result);
});
}
}
常见误区
- 误区:EventLoop 线程越多越好?正解:EventLoop 线程数一般 CPU * 2,太多了反而上下文切换开销大。
- 误区:ChannelHandler 里可以随便加锁?正解:同一个 Channel 的所有操作都在同一个 EventLoop 线程,本来就是串行的,不用加锁。
追问 / 延伸
- 什么是串行化?答:同一个 Channel 的所有事件按顺序执行,不会并发,所以不用加锁。
- 怎么看 EventLoop 是不是被阻塞了?答:如果一个 EventLoop 处理事件很慢,这个 EventLoop 上的所有连接都会慢。
04.1.4.1-008 LengthFieldBasedFrameDecoder 怎么用?
频率 ★★★★☆ | 难度 进阶
一句话结论
LengthFieldBasedFrameDecoder 是 Netty 内置的拆包解码器:从消息里读一个长度字段,按这个长度把后面的内容拆成一个完整消息,解决粘包拆包问题,是最常用的 TCP 协议解码器。
概念解释
- 消息格式:长度字段(4 字节)+ 消息体(N 字节)。
- LengthFieldBasedFrameDecoder 参数:
- maxFrameLength:最大消息长度,防止内存爆掉。
- lengthFieldOffset:长度字段在消息里的偏移量。
- lengthFieldLength:长度字段占几个字节(1、2、4、8)。
- lengthAdjustment:长度字段的补偿值(长度字段后面还有多少字节的头)。
- initialBytesToStrip:解码后跳过多少字节(跳过长度字段本身)。
原理流程
- 接收数据,先看累计的字节数够不够读长度字段。
- 如果够,读出长度字段的值 N。
- 再看累计的字节数够不够 N 字节的消息体。
- 如果够,把长度字段 + 消息体作为一个完整消息传给下一个 Handler。
- 如果不够,等下次更多数据过来再处理。
代码 / 示例
// 消息格式:魔数(4字节) + 版本(1字节) + 长度(4字节) + 消息体(N字节)
// 长度字段的值 = 版本 + 消息体 的总长度
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(
1024 * 1024, // 最大 1MB
5, // 长度字段偏移:前面有 4 字节魔数 + 1 字节版本
4, // 长度字段占 4 字节
1, // 补偿值:长度字段的值是版本 + 消息体,版本占 1 字节
0 // 不跳过,把完整的头 + 体传给下一个 Handler
));
// 之后再接一个业务解码器,把 ByteBuf 转成 Java 对象
ch.pipeline().addLast(new MyProtocolDecoder());
常见误区
- 误区:LengthFieldBasedFrameDecoder 所有参数都设 0 就行?正解:参数要根据你的协议格式来,设错了解码出来的消息是错的。
- 误区:长度字段的值就是消息体的长度?正解:要看协议定义,有的长度字段是整个消息的长度,有的是消息体的长度,要加 lengthAdjustment 补偿。
追问 / 延伸
- 为什么要有 initialBytesToStrip?答:长度字段是给解码器用的,业务代码不需要,所以解码后跳过长度字段,直接给业务代码消息体。
- 什么是自定义协议?答:自己定义消息格式,比如魔数、版本、消息类型、长度、消息体,比 HTTP 更轻量,适合内部 RPC 调用。
待整理清单
- [ ] Netty 心跳机制与断线重连
- [ ] Protobuf 编解码实战
- [ ] Netty 内存泄漏检测
- [ ] Netty 性能调优参数