罗罗编程学习记录
本页内容 展开查看

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 请求后立刻返回,操作系统完成数据拷贝后回调通知应用。

原理流程

  1. BIO:每来一个连接,服务端开一个线程处理,线程在 read() 时阻塞,直到数据到达。
  2. NIO:所有连接注册到 Selector,一个线程轮询 Selector,发现哪个连接有读事件,就处理哪个连接。
  3. 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 列表到内核。

原理流程

  1. 把所有连接的 Channel 注册到 Selector,告诉 Selector 关心哪些事件。
  2. 线程调用 selector.select(),阻塞在操作系统层面。
  3. 某个连接有数据可读时,操作系统把这个 fd 放到就绪列表。
  4. select() 返回,线程拿到就绪的 Channel 列表,逐个处理。
  5. 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。

原理流程

  1. 单 Reactor 单线程:一个线程跑 Selector,接连接、读数据、写数据、业务逻辑全在这个线程。
  2. 单 Reactor 多线程:Reactor 线程负责读数据,读完丢给业务线程池处理,写完再丢回 Reactor 线程写。
  3. 主从 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:数据从磁盘读进内核缓冲区,直接送到网卡,不经过用户态。

原理流程

  1. 传统的 read + write:磁盘 → 内核缓冲区 → 用户缓冲区 → Socket 缓冲区 → 网卡,四次拷贝。
  2. sendfile:磁盘 → 内核缓冲区 → 网卡,两次拷贝,数据不经过用户态。
  3. 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 支持自动扩展:写满了自动扩容,不用手动检查。

原理流程

  1. ByteBuffer:写数据时 position 往后移,读完要 flip(),把 position 切到 0,limit 设成原来的 position。
  2. ByteBuf:writerIndex 指向写的位置,readerIndex 指向读的位置,写的时候 writerIndex 往后移,读的时候 readerIndex 往后移,互不干扰。
  3. 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(最大分段大小)会把大包拆分。

原理流程

  1. 发送方调用 send(P1)、send(P2),TCP 可能把两个包合并成一个发出去。
  2. 接收方 recv() 一次读到 P1P2,不知道哪里是 P1 的结尾。
  3. 或者发送方发了一个 1000 字节的包,MSS 是 1460 但 MTU 限制,拆成两个包发。
  4. 接收方第一次只读到 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 的所有操作都在同一个线程,不用加锁,线程安全。

原理流程

  1. 客户端连接上来,ServerBootstrap 从 workerGroup 里选一个 EventLoop。
  2. 把这个 SocketChannel 注册到这个 EventLoop 的 Selector。
  3. 之后这个连接的所有读、写、事件回调,都在这个 EventLoop 线程执行。
  4. 业务代码如果耗时,要丢到业务线程池,否则会阻塞这个 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:解码后跳过多少字节(跳过长度字段本身)。

原理流程

  1. 接收数据,先看累计的字节数够不够读长度字段。
  2. 如果够,读出长度字段的值 N。
  3. 再看累计的字节数够不够 N 字节的消息体。
  4. 如果够,把长度字段 + 消息体作为一个完整消息传给下一个 Handler。
  5. 如果不够,等下次更多数据过来再处理。

代码 / 示例

// 消息格式:魔数(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 性能调优参数