一、NIO 诞生的背景：为什么需要非阻塞 IO？

在 Java 早期的 IO 模型（OIO，Old IO）中，服务器采用“每连接一线程”模式（Connection Per Thread）。例如，传统的 BIO 服务器为每个 Socket 连接分配独立线程处理读写，这种模式在连接数较低时（如小于 1000）表现良好，但面临高并发场景时暴露出致命缺陷：

• 线程资源昂贵：线程创建/销毁成本高（涉及系统调用），单个线程栈内存占用 512KB~1MB，千级线程即消耗 1GB 内存。
• 上下文切换开销：大量线程频繁切换导致 CPU 内核态（sy）占用率飙升（超过 20%），系统性能急剧下降。
• 负载波动大：突发流量可能激活大量阻塞线程，导致系统负载锯齿状波动，甚至崩溃。

案例：早期 Tomcat 采用 BIO 模型，在万级连接时因线程耗尽而无法响应新请求。随着移动互联网和实时通信的兴起，百万级长连接需求催生了 Java NIO（New IO），其核心目标是通过非阻塞 IO + 多路复用技术，实现单线程管理海量连接。

二、NIO vs OIO：核心区别

示意图：OIO 与 NIO 的线程模型对比

 OIO 模型：
 客户端连接 1 → 线程 1（阻塞读写）
 客户端连接 2 → 线程 2（阻塞读写）
 ...
 NIO 模型：
 Selector 线程 → 监控通道 1、通道 2...（非阻塞读写）

三、NIO 核心组件详解

3.1 通道（Channel）：双向数据传输管道

• 作用：替代 OIO 中的流，支持双向读写，数据需通过缓冲区交互。
• 类型：
  • FileChannel：文件 IO（阻塞模式）。
  • SocketChannel：TCP 客户端连接，支持非阻塞。
  • ServerSocketChannel：TCP 服务器监听，支持非阻塞。
  • DatagramChannel：UDP 数据报通信，支持非阻塞。

示例：通过 SocketChannel 建立非阻塞连接

 // 客户端
 SocketChannel socketChannel = SocketChannel.open();
 socketChannel.configureBlocking(false); // 设置非阻塞
 socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
 ​
 // 服务器
 ServerSocketChannel serverChannel = ServerSocketChannel.open();
 serverChannel.configureBlocking(false);
 serverChannel.bind(new InetSocketAddress(8080));

3.2 缓冲区（Buffer）：数据存储与操作的核心

• 本质：一块连续的内存块，支持读写切换，通过四个属性管理状态：
  • capacity：缓冲区总容量（固定不变）。
  • position：下一个读写位置（读写模式下含义不同）。
  • limit：读写上限（写模式下为 capacity，读模式下为已写入数据量）。
  • mark：标记当前 position，可通过 reset() 恢复。

缓冲区操作流程：

1. 写入模式：调用 put() 写入数据，position 递增。
2. 切换读模式：调用 flip()，limit=position，position=0。
3. 读取数据：调用 get()，position 递增。
4. 重置写入：调用 clear() 或 compact()，position=0，limit=capacity。

代码示例：缓冲区基本操作

 // 分配容量为 10 的 IntBuffer
 IntBuffer buffer = IntBuffer.allocate(10);
 ​
 // 写入数据
 buffer.put(10).put(20); // position=2
 buffer.flip(); // 切换读模式，limit=2，position=0
 ​
 // 读取数据
 int a = buffer.get(); // a=10，position=1
 int b = buffer.get(); // b=20，position=2
 ​
 buffer.clear(); // 重置，position=0，limit=10

3.3 选择器（Selector）：多路复用的核心

• 作用：单线程监控多个通道的 IO 事件（可读、可写、连接完成、新连接），避免线程阻塞。
• 关键步骤：
  1. 注册通道：将通道注册到 Selector，并指定感兴趣的事件（如 OP_READ）。
  2. 轮询事件：调用 selector.select() 获取就绪事件的 SelectionKey 集合。
  3. 处理事件：根据事件类型（isReadable()/isAcceptable() 等）处理业务逻辑。

示例：SelectableChannel 注册与事件处理

 Selector selector = Selector.open();
 ServerSocketChannel serverChannel = ServerSocketChannel.open();
 serverChannel.configureBlocking(false);
 serverChannel.bind(new InetSocketAddress(8080));
 ​
 // 注册接收新连接事件
 serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 ​
 while (selector.select() > 0) { // 阻塞直到有事件就绪
     Set<SelectionKey> keys = selector.selectedKeys();
     for (SelectionKey key : keys) {
         if (key.isAcceptable()) {
             // 处理新连接
             SocketChannel clientChannel = serverChannel.accept();
             clientChannel.configureBlocking(false);
             clientChannel.register(selector, SelectionKey.OP_READ);
         } else if (key.isReadable()) {
             // 处理读事件
             SocketChannel clientChannel = (SocketChannel) key.channel();
             ByteBuffer buffer = ByteBuffer.allocate(1024);
             clientChannel.read(buffer);
             // 处理数据...
         }
         keys.remove(key); // 移除已处理的键，避免重复处理
     }
 }

四、NIO 高性能的底层原理

NIO 基于操作系统的 IO 多路复用技术，不同系统实现略有差异：

• Windows：使用 select 模型。
• Linux：早期使用 select/poll，现代内核推荐 epoll（性能更高，支持万级连接）。

IO 多路复用模型对比：

Java NIO 通过 Selector 封装了底层差异，开发者无需关心具体实现，只需关注通道和事件处理。

五、入门示例：NIO 实现简单文件服务器

5.1 需求说明

• 客户端向服务器发送文件，服务器接收并保存。
• 使用 NIO 的非阻塞模式和 Selector 实现高并发处理。

5.2 核心流程

1. 服务器端：
   • 注册 ServerSocketChannel 到 Selector，监听 OP_ACCEPT 事件（新连接）。
   • 接收连接后，注册 SocketChannel 到 Selector，监听 OP_READ 事件（数据可读）。
   • 读取文件数据并写入本地文件。
2. 客户端：
   • 通过 SocketChannel 连接服务器，分批次发送文件名、文件长度、文件内容。

5.3 关键代码（服务器端）

 public class NioFileServer {
     private static final int PORT = 8080;
     private Selector selector;
 ​
     public void start() throws IOException {
         selector = Selector.open();
         ServerSocketChannel serverChannel = ServerSocketChannel.open();
         serverChannel.configureBlocking(false);
         serverChannel.bind(new InetSocketAddress(PORT));
         serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 ​
         System.out.println("Server started on port " + PORT);
 ​
         while (true) {
             int readyChannels = selector.select();
             if (readyChannels == 0) continue;
 ​
             Set<SelectionKey> keys = selector.selectedKeys();
             for (SelectionKey key : keys) {
                 if (key.isAcceptable()) {
                     handleAccept(key);
                 } else if (key.isReadable()) {
                     handleRead(key);
                 }
                 keys.remove(key);
             }
         }
     }
 ​
     private void handleAccept(SelectionKey key) throws IOException {
         ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
         SocketChannel clientChannel = serverChannel.accept();
         clientChannel.configureBlocking(false);
         clientChannel.register(selector, SelectionKey.OP_READ);
         System.out.println("New client connected: " + clientChannel);
     }
 ​
     private void handleRead(SelectionKey key) throws IOException {
         SocketChannel clientChannel = (SocketChannel) key.channel();
         ByteBuffer buffer = ByteBuffer.allocate(1024);
         int bytesRead = clientChannel.read(buffer);
 ​
         if (bytesRead > 0) {
             buffer.flip();
             // 解析文件名、文件内容并保存...
             System.out.println("Received data from client: " + new String(buffer.array(), 0, bytesRead));
         } else if (bytesRead == -1) {
             System.out.println("Client disconnected: " + clientChannel);
             clientChannel.close();
         }
     }
 ​
     public static void main(String[] args) throws IOException {
         new NioFileServer().start();
     }
 }

六、总结：NIO 的优势与适用场景

• 优势：
  • 高性能：单线程处理海量连接，减少线程上下文切换开销。
  • 低资源占用：无需为每个连接创建独立线程，节省内存和 CPU 资源。
  • 灵活的 API：通过缓冲区和选择器实现复杂的异步逻辑。
• 适用场景：
  • 高并发网络服务器（如 Web 服务器、即时通信服务器）。
  • 海量文件存储与处理系统。
  • 微服务架构中的高性能通信组件（如 Netty 基于 NIO 实现）。

延伸学习：NIO 虽然强大，但直接使用复杂度较高。推荐学习 Netty 框架，其封装了 NIO 的底层细节，提供更易用的 API 和高性能的通信解决方案。

通过本文，你已掌握 Java NIO 的核心概念和入门实践。接下来可深入研究缓冲区的高级用法（如内存映射 MappedByteBuffer）、选择器的优化策略，或结合实际项目场景进行实战演练。