先用表格详细绘制 BIO → NIO（非阻塞轮询）→ select/poll → epoll → Java NIO Selector → Netty 的完整演进路线图。

演进阶段	代表技术 / 组件	核心机制	解决的痛点	遗留问题 / 新挑战	操作系统系统调用 / 底层实现
原始阻塞 I/O (1980s)	BIO (发布于1996年的Java 1.0 Socket/ServerSocket)	每连接一个独立线程，accept()、read()、write() 阻塞线程	编程模型简单，顺序执行，易于理解	连接数增长时线程资源爆炸（内存、上下文切换），无法支撑高并发（C10K问题）	内核 accept、read、write 系统调用（阻塞模式）
非阻塞 I/O 轮询 (1990s)	Java NIO 的 configureBlocking(false)（未使用 Selector）	单线程循环遍历所有连接，非阻塞 read() 立即返回（无数据返回0或-1）	单线程可管理多个连接，避免为每个连接创建线程	CPU 空转：即使99%连接空闲，仍需频繁系统调用；无效遍历 O(N) 开销	非阻塞 read/write，通过 fcntl 设置 O_NONBLOCK
I/O 多路复用雏形 (1983)	select 系统调用	内核监听多个 fd，当任一 fd 就绪时返回；用户态需遍历 fd_set 找到就绪 fd	内核集中通知就绪事件，避免用户态主动轮询所有 fd	① fd 上限 1024；② 每次调用拷贝整个 fd_set；③ 返回后仍需 O(N) 遍历所有 fd（N=最大fd编号）	select 系统调用
改进型多路复用 (1986)	poll 系统调用	基于链表结构，无 fd 上限；pollfd 数组区分 events 与 revents	消除 fd 上限限制，结构更清晰	每次调用仍需拷贝整个 pollfd 数组；返回后仍需 O(N) 遍历所有传入的 fd（N=总 fd 数）	poll 系统调用
事件驱动多路复用 (2002, Linux)	epoll 系统调用	① epoll_ctl 注册 fd 时内核注册回调；② 就绪时回调将 fd 放入就绪链表；③ epoll_wait 直接返回就绪链表	O(1) 复杂度（仅处理活跃连接）；无 fd 上限；无需每次拷贝全部 fd	编程复杂（边缘触发 ET 需处理非阻塞读写完全），非跨平台（Linux only）	epoll_create、epoll_ctl、epoll_wait
跨平台封装 (Java 1.4, 2002)	Java NIO Selector	统一 API，底层根据不同 OS 自适应使用 epoll/poll/select/kqueue	屏蔽底层差异，简化多路复用编程；支持非阻塞 + 事件驱动	API 仍较底层（ByteBuffer、SelectionKey），易出错（如忘记 remove()）；缺少高级协议编解码支持	Linux → epoll；macOS → kqueue；其他 → poll/select
高性能网络框架 (2004)	Netty	① Reactor 线程模型（Boss/Worker）；② 内存池 + 零拷贝；③ 管道（Pipeline）编解码；④ 异步非阻塞 API	解决原生 NIO 的复杂性和易错性；提供高效线程模型；内置协议支持（HTTP/2、WebSocket 等）；减少 GC	学习曲线较陡；框架层抽象增加一定开销（相比裸 epoll 微乎其微）	复用底层 NIO 或 epoll（通过 netty-transport-native-epoll 直接调用原生 epoll）

核心要点

• BIO → 非阻塞轮询 解决了“线程爆炸”问题，但引入了“CPU 空转”。
• select/poll 解决了“用户态盲轮询”，但仍有 O(N) 扫描开销。
• epoll 实现了真正的事件驱动，复杂度降至 O(1)，成为现代高并发服务器（Nginx、Redis、Netty）的基础。
• Java NIO Selector 是跨平台封装，让开发者可以在 JVM 上使用多路复用。
• Netty 是对 NIO 的工业级封装，屏蔽底层细节，提供生产级高并发能力。

---

以下详细涵盖 BIO → NIO → IO多路复用器 → Netty 的演进历史、核心知识点、操作系统系统调用，并贴出了 Java NIO 多路复用器的完整代码示例。

一、BIO (Blocking I/O) —— 同步阻塞模型

核心知识点

• 模型：每个客户端连接对应一个独立线程。
• 阻塞点(2个)：
  • accept()：等待连接时阻塞。
  • read() / write()：等待数据读写时阻塞。
• 代码示意：

  ServerSocket server = new ServerSocket(8080);
  while (true) {
      Socket socket = server.accept(); // 阻塞点1：等待客户端连接，直到有新的连接请求到达才会返回。
      new Thread(() -> {
          try {
              BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
              String line;
              while ((line = in.readLine()) != null) {  // 阻塞点2：等待读取客户端发送的一行数据，直到收到换行符（\n 或 \r\n）或流结束才会返回。若客户端迟迟不发数据，该线程会一直阻塞在此。
                  System.out.println("received: " + line);
                  socket.getOutputStream().write((line + "\n").getBytes());
              }
          } catch (IOException e) { e.printStackTrace(); }
      }).start();
  }
  

存在问题

• 线程开销巨大：每个连接一个线程，1万个连接需要1万个线程 → 内存占用高（每线程栈约1MB），上下文切换频繁。
• C10K 问题：无法高效处理一万个以上的并发连接。
• 资源浪费：多数连接空闲时，线程仍在阻塞。

演进驱动

如何用一个线程管理多个连接？

---

二、NIO (Non-blocking I/O) —— Java 层面的非阻塞轮询

注意：此处的 NIO 指 Java 1.4 引入的 java.nio 包提供的非阻塞模式，不包含 Selector（即单纯的 Channel 非阻塞）。

核心知识点

• 将 ServerSocketChannel 和 SocketChannel 设置为非阻塞模式。
• 单线程循环遍历所有连接，调用 read() 立即返回（无数据时返回 0 或 -1）。

代码示意（无 Selector）

ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.bind(new InetSocketAddress(8080));
List<SocketChannel> clients = new ArrayList<>();

while (true) {
    SocketChannel client = server.accept(); // 非阻塞，无连接时返回 null
    if (client != null) {
        client.configureBlocking(false);
        clients.add(client);
    }
    for (SocketChannel ch : clients) {
        ByteBuffer buf = ByteBuffer.allocate(1024);
        int n = ch.read(buf); // 非阻塞，立即返回
        if (n > 0) {
            buf.flip();
            ch.write(buf);
        }
    }
}

解决了什么？

• 单线程可以管理多个连接，不再为每个连接分配独立线程。

遗留问题

• CPU 空转：必须无限循环遍历所有连接，即使 99% 的连接没有数据，也要反复调用 read() 系统调用 → 用户态/内核态切换开销大，CPU 占用 100%。
• 无效遍历：复杂度 O(N)，N=总连接数。

演进驱动

如何让操作系统通知“哪些连接真正有数据”，而不是程序盲目轮询？

---

三、IO 多路复用器 —— 操作系统内核提供的解决方案

三大系统调用对比

系统调用	时间复杂度	最大描述符数	数据拷贝	触发方式
select	O(N)（N=最大 fd+1）	1024（通常）	每次拷贝全部 fd_set	水平触发
poll	O(N)（N=传入的 fd 数）	无硬性上限	每次拷贝全部 pollfd 数组	水平触发
epoll	O(1)（仅活跃连接）	系统最大打开文件数	仅拷贝就绪的 fd	水平/边缘触发

详细用法

1. select

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);

• 流程：用户态设置 fd_set → 调用 select（内核阻塞）→ 返回后遍历所有 fd 检查是否在集合中。
• 缺陷：每次调用拷贝整个集合；返回后需要 O(N) 扫描；fd 上限 1024。

2. poll

int poll(struct pollfd *fds, nfds_t nfds, int timeout);
struct pollfd {
    int fd;          // 文件描述符
    short events;    // 感兴趣的事件（POLLIN/POLLOUT）
    short revents;   // 实际发生的事件（内核填充）
};

• 改进：无最大 fd 限制；结构清晰区分 events 和 revents。
• 仍存问题：每次调用需拷贝整个 pollfd 数组；返回后仍需遍历所有 nfds 找出 revents != 0 的 fd → O(N) 扫描。

3. epoll（Linux 高性能核心）

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

• 工作原理：
  • epoll_create 在内核创建 eventpoll 对象，返回句柄。
  • epoll_ctl 添加/修改 fd 时，内核为该 fd 注册回调函数。当 fd 就绪，回调函数将其放入内核的就绪链表。
  • epoll_wait 直接从就绪链表拷贝事件到用户态数组（仅就绪的 fd）。
• 优势：
  • O(1) 复杂度：只返回活跃连接，无需遍历全部。
  • 支持边缘触发 (ET) 和水平触发 (LT)，避免重复唤醒。

Java NIO 中的 Selector 封装

Java 的 Selector 在不同操作系统底层使用不同的多路复用器：

• Linux：epoll（Java 1.5+ 默认使用 EPollSelectorProvider）
• macOS：kqueue（Java 7+ 开始支持）或 poll
• 其他 Unix：poll 或 select

---

四、完整 Java NIO + Selector 代码

下面是一个完整的 Echo 服务器，使用 Selector 实现 IO 多路复用，可以同时处理数千个连接，代码完整可运行。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class NioEchoServer {

    public static void main(String[] args) throws IOException {
        // 1. 创建 Selector（多路复用器）
        Selector selector = Selector.open();

        // 2. 创建 ServerSocketChannel 并设置为非阻塞模式
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);

        // 3. 绑定端口
        serverChannel.bind(new InetSocketAddress(8080));

        // 4. 将 ServerSocketChannel 注册到 Selector，关注 OP_ACCEPT 事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Echo server started on port 8080");

        // 5. 事件循环（无限循环处理就绪的 I/O 事件）
        while (true) {
            // 阻塞等待至少一个就绪事件（可设置超时参数，此处无限等待）
            int readyChannels = selector.select();
            if (readyChannels == 0) {
            	// 没有就绪事件，继续阻塞
                continue;
            }

            // 获取所有就绪的 SelectionKey
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();

                try {
                    // 处理 OP_ACCEPT 事件（新的客户端连接）
                    if (key.isAcceptable()) {
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        SocketChannel clientChannel = server.accept();
                        if (clientChannel != null) {
                            clientChannel.configureBlocking(false);
                            // 将新连接的 SocketChannel 注册到同一个 Selector，关注 OP_READ 事件
                            clientChannel.register(selector, SelectionKey.OP_READ);
                            System.out.println("New connection from: " + clientChannel.getRemoteAddress());
                        }
                    }

                    // 处理 OP_READ 事件（客户端发送数据到达）
                    if (key.isReadable()) {
                        SocketChannel clientChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        int readBytes = clientChannel.read(buffer);

                        if (readBytes == -1) {
                            // 客户端正常关闭连接
                            System.out.println("Connection closed by client: " + clientChannel.getRemoteAddress());
                            clientChannel.close();
                            key.cancel();   // 取消注册
                            continue;
                        }

                        if (readBytes > 0) {
                            // 翻转缓冲区，准备读取数据
                            buffer.flip();
                            byte[] data = new byte[buffer.remaining()];
                            buffer.get(data);
                            String message = new String(data);
                            System.out.println("Received: " + message);

                            // 原样回显给客户端
                            // 注意：简单场景下直接 write 可以，大数据量时可能需要注册 OP_WRITE 事件处理写阻塞
                            buffer.rewind();   // 重置 position 为 0，准备发送
                            clientChannel.write(buffer);
                        }
                    }

                    // 处理 OP_WRITE 事件（通常不直接注册，避免忙循环）
                    // 本例省略

                } catch (IOException e) {
                    // 出现异常时，关闭连接并取消注册
                    e.printStackTrace();
                    key.channel().close();
                    key.cancel();
                } finally {
                    // 移除已处理的 SelectionKey，避免下次重复处理（必须）
                    keyIterator.remove();
                }
            }
        }
    }
}

代码关键说明

• Selector.open()：底层调用 epoll_create 或 poll 初始化。
  底层会调用操作系统的多路复用系统调用：Linux 上优先使用 epoll（EPollSelectorProvider），其他系统可能使用 poll 或 select。
• channel.register(selector, ops)：底层调用 epoll_ctl 添加 fd 到监听集合。
  将通道注册到多路复用器，并声明感兴趣的事件（接收连接、读、写）。每个通道可以注册多个事件。
• selector.select()：底层调用 epoll_wait，内核阻塞直到有事件就绪。
  核心阻塞方法，它会调用内核的 epoll_wait（或 poll/select）。当没有任何就绪事件时，线程在此休眠；当内核检测到至少一个注册的 fd 上发生了感兴趣的事件，线程被唤醒并返回就绪事件的数量。
• selector.selectedKeys()：返回就绪事件的集合（内核就绪链表）。
  必须遍历并处理每一个 SelectionKey，处理完后显式地从集合中移除，否则下次 select() 会重复处理。
• key.isAcceptable() / key.isReadable()
  判断事件类型，然后获取对应的 Channel 进行 I/O 操作。
• **非阻塞读写**SocketChannel的read() 和 write() 在非阻塞模式下会立即返回已经读/写的字节数，不会阻塞线程。如果 read() 返回 -1 表示对方关闭了连接。
• keyIterator.remove()：必须手动移除已处理的事件，否则下次 select() 会重复处理。

---

五、演进历史汇总

阶段	技术	解决的问题	遗留问题
阻塞I/O	BIO	编程简单，顺序执行	每连接一线程，资源爆炸
非阻塞轮询	NIO（无 Selector）	单线程管理多连接	CPU 忙轮询，无效系统调用
操作系统多路复用	select / poll	内核告知就绪事件	O(N) 扫描，fd 上限或拷贝开销
高效多路复用	epoll (Linux)	O(1) 事件驱动，无 fd 上限	编程复杂，非跨平台
跨平台封装	Java NIO Selector	统一 API，底层自适应	API 仍较底层，易出错
高性能框架	Netty	封装细节，线程模型优化，零拷贝	学习曲线较陡

---

六、Netty 的核心优化

Netty 不是新的多路复用器，而是基于 Java NIO / epoll 的高性能网络框架，解决了原生 NIO 的痛点：

1. API 易用性：

   • 提供 ByteBuf（自动扩容、池化、引用计数）替代 ByteBuffer。
   • 内置编解码器（解决粘包半包问题）。
   • 管道（Pipeline）模式，方便添加业务逻辑。

2. 线程模型：

   • 基于 Reactor 模型：BossGroup 负责接收连接，WorkerGroup 负责 I/O 读写。
   • 保证同一个 Channel 的所有事件在同一个 EventLoop 中串行处理，避免锁竞争。

3. 零拷贝：

   • 通过 FileRegion 利用 sendfile 系统调用，将文件直接从内核缓冲区发到 socket，避免用户态拷贝。

4. 高性能数据结构：

   • 无锁化设计（串行化 + CAS）。
   • 对象池（Recycler）减少 GC。

5. 更底层优化：

   • 直接使用 Linux 原生 epoll（通过 netty-transport-native-epoll），避免 JDK 的额外开销。

---

七、总结

• BIO：适合连接数少且活跃的场景（如数据库连接池）。
• 非阻塞 NIO（无 Selector）：不实用，仅用于理解概念。
• IO 多路复用（Selector + epoll）：Java 高并发网络编程的基础，适合处理大量长连接。
• Netty：生产环境首选，几乎所有 Java 高性能网络中间件（Dubbo、RocketMQ、Elasticsearch）都基于 Netty。