个人网站

Netty 为什么这么快？很多人说"因为用了 NIO"，但 NIO 只是基础，真正让 Netty 高性能的核心设计是 Reactor 模式。面试官问这题，他想听的是：Reactor 模式有哪几种？Netty 用的是哪种？为什么？

先说结论

维度	说明
Reactor 模式	基于 I/O 多路复用的事件驱动模型
三种变体	单 Reactor 单线程、单 Reactor 多线程、主从 Reactor
Netty 采用	主从 Reactor 多线程模型
Boss Group	主 Reactor，负责 Accept 连接
Worker Group	从 Reactor，负责 I/O 读写和业务处理

一句话记住：Reactor 模式就像餐厅的迎宾和服务员——迎宾（Boss）只管接客，服务员（Worker）只管上菜，各司其职效率最高

为什么需要Reactor模式

传统 BIO 模型：一个连接一个线程。

客户端1 → 线程1（阻塞等待读）
客户端2 → 线程2（阻塞等待读）
客户端3 → 线程3（阻塞等待读）
...
客户端10000 → 线程10000（💥 线程爆炸）

一万个连接就要一万个线程，CPU 在线程切换上累死，真正干活的没几个。

Reactor 模式的思路：一个线程监听多个连接的 I/O 事件，谁有数据就处理谁。

Selector（一个线程监听 10000 个连接）
    ├── 连接1 有数据可读 → 处理
    ├── 连接5 有数据可读 → 处理
    └── 连接99 有新连接 → Accept

就像餐厅迎宾——不需要一个服务员盯着一桌客人，迎宾统一看哪个客人招手了就安排对应服务员去服务。

三种Reactor模型

单Reactor单线程

Reactor 线程
├── Accept 连接
├── Read 请求
├── 业务处理
└── Write 响应

所有工作都在一个线程中完成。简单，但性能差——一个慢请求会阻塞所有其他请求。

就像小餐馆，老板一个人又迎宾又点菜又炒菜——客人多了就忙不过来。

单Reactor多线程

Reactor 线程
├── Accept 连接
└── Read 请求 → 提交到线程池
                    ├── Worker1 处理业务 + Write 响应
                    ├── Worker2 处理业务 + Write 响应
                    └── Worker3 处理业务 + Write 响应

一个线程负责 Accept 和 Read，业务处理交给线程池。比单线程好，但 Reactor 线程仍是瓶颈——所有连接的 Accept 和 Read 都由它一人承担。

就像餐馆升级了——老板只管迎宾和接单，炒菜交给厨师团队。但老板一个人接单还是忙不过来。

主从Reactor多线程（Netty采用）

MainReactor（Boss Group）
├── Boss1: Accept 连接 → 分配给 Worker
└── Boss2: Accept 连接 → 分配给 Worker

SubReactor（Worker Group）
├── Worker1: Read + Write
├── Worker2: Read + Write
└── Worker3: Read + Write

Main Reactor 只负责 Accept 连接，Sub Reactor 负责 I/O 读写，业务处理可以交给 Worker 线程或单独的业务线程池。

就像大餐厅——迎宾团队（Boss Group）只管带客人入座，服务员团队（Worker Group）只管点菜上菜，分工明确效率最高。

Netty的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)                          // 👈 配置主从 Reactor
 .channel(NioServerSocketChannel.class)
 .childHandler(new ChannelInitializer<SocketChannel>() {
     @Override
     protected void initChannel(SocketChannel ch) {
         ch.pipeline().addLast(new MyHandler());          // 👈 业务处理
     }
 });

Boss Group 做什么

// Boss EventLoop 的工作循环
while (true) {
    SelectionKey key = selector.select();    // 👈 监听 OP_ACCEPT 事件
    if (key.isAcceptable()) {
        SocketChannel client = serverChannel.accept();  // 👈 接受新连接
        workerGroup.register(client);       // 👈 把连接分配给 Worker
    }
}

Boss 只关心一件事：有没有新连接进来。1 个线程就够了——Accept 操作非常轻量。

Worker Group 做什么

// Worker EventLoop 的工作循环
while (true) {
    SelectionKey key = selector.select();    // 👈 监听 OP_READ / OP_WRITE
    if (key.isReadable()) {
        readData(channel);                  // 👈 读取数据
        pipeline.fireChannelRead(msg);      // 👈 交给 Pipeline 处理
    }
}

Worker 关心两件事：读数据、写数据。每个 Worker 负责一批连接的 I/O 操作。

为什么Boss只要1个线程

Accept 操作是 O(1) 的——只是从全连接队列取一个连接，非常快。1 个线程完全够用，多了反而浪费。

如果 Boss 有多个线程，多个线程同时 Accept 同一个 ServerSocketChannel，还需要同步——反而降低性能。

Reactor 模式全景

三种变体
├── 单 Reactor 单线程 —— 简单但性能差
├── 单 Reactor 多线程 —— Reactor 仍是瓶颈
└── 主从 Reactor 多线程 —— Netty 采用，性能最优

Netty 实现
├── Boss Group（主 Reactor）—— Accept，1个线程
├── Worker Group（从 Reactor）—— Read/Write，CPU*2 个线程
└── Pipeline —— 业务处理链

核心优势
├── 职责分离（Accept vs I/O）
├── 非阻塞 I/O（Selector 多路复用）
└── 事件驱动（谁有数据处理谁）

口诀：单Reactor性能差，多线程还是瓶颈；
      主从Reactor最优秀，Boss接客Worker忙；
      Boss只要一个线，Accept轻量不费时；
      Worker默认CPU乘2，读写分离效率高

回答技巧与点评

标准回答：Reactor 模式是基于 I/O 多路复用的事件驱动模型，有三种变体：单 Reactor 单线程、单 Reactor 多线程、主从 Reactor 多线程。Netty 采用主从 Reactor 多线程模型：Boss Group（主 Reactor）负责 Accept 新连接，Worker Group（从 Reactor）负责 I/O 读写。Boss 通常 1 个线程（Accept 操作轻量），Worker 默认 CPU 核数×2 个线程。这种模型将连接建立和数据读写分离，充分利用多核性能。

加分回答

1. Reactor 模式的来源：Reactor 模式由 Douglas C. Schmidt 在 1995 年提出，最初用于 ACE（Adaptive Communication Environment）框架。Netty 的实现是对这个模式的工业级优化
2. EventLoop 的本质：Netty 的 EventLoop 是一个 单线程事件循环，每个 Channel 在整个生命周期中只绑定一个 EventLoop，保证了 Channel 的操作是线程安全的，无需加锁
3. 业务线程池：如果业务处理耗时，可以在 Pipeline 中添加自定义线程池（DefaultEventExecutorGroup），避免阻塞 Worker 的 I/O 操作——这实际上是在主从 Reactor 之外加了一层业务处理线程池

面试官点评

这道题考的是你对 Netty 架构设计 的理解深度。能说出三种 Reactor 变体和 Netty 采用主从模型算及格，高分的关键在于：讲清楚 Boss 和 Worker 的职责分离，以及 为什么 Boss 只要 1 个线程。如果你能提到 EventLoop 的单线程绑定和业务线程池的扩展，说明你理解得很透彻。

原文阅读

---

内容有帮助？点赞、收藏、关注三连！评论区等你 💪