javaNIO详解

Java NIO（Non-blocking I/O）详解

Java NIO（New I/O）是 Java 1.4 引入的高性能 I/O 框架，相比传统的 BIO（Blocking I/O），它提供了非阻塞、多路复用、零拷贝等能力，适用于高并发网络通信和文件操作。下面详细解析其核心概念和实现原理。

1. Java NIO 的核心组件

Java NIO 的核心由 Channel（通道）、Buffer（缓冲区）、Selector（选择器） 组成：

2. NIO 的工作流程

(1) 传统 BIO（阻塞 I/O）的问题

• 每个连接占用一个线程，线程切换开销大。
• 线程阻塞：当没有数据可读时，线程会一直等待，浪费 CPU 资源。

(2) NIO 的非阻塞模型

NIO 采用 事件驱动（Event-Driven） 的方式：

1. Channel 注册到 Selector，并指定监听的事件（如 OP_READ、OP_WRITE）。
2. Selector 轮询 所有注册的 Channel，返回就绪的事件。
3. 线程处理就绪事件（如读取数据、写入数据），避免阻塞。

关键优化：
• 单线程可管理多个连接（减少线程数）。
• 非阻塞：没有数据时，线程可以处理其他任务。

3. NIO 的核心实现

(1) Channel（通道）

• SocketChannel：用于 TCP 网络通信（客户端/服务端）。
• ServerSocketChannel：服务端监听新连接。
• FileChannel：文件操作（支持 mmap 和 sendfile）。

示例：创建 SocketChannel

SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false); // 设置为非阻塞模式
socketChannel.connect(new InetSocketAddress("example.com", 80));

(2) Buffer（缓冲区）

• ByteBuffer：最常用的缓冲区（支持堆内存和直接内存）。
• CharBuffer、IntBuffer：其他数据类型的缓冲区。

Buffer 的读写流程：

ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配堆内存
// 写入数据
buffer.put("Hello".getBytes());
buffer.flip(); // 切换为读模式
// 读取数据
while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get());
}
buffer.clear(); // 清空缓冲区，准备下一次写入

直接内存（DirectBuffer）优化：
• ByteBuffer.allocateDirect() 分配堆外内存，减少 JVM GC 压力。
• 适合高频 I/O 操作（如网络传输、文件映射）。

(3) Selector（选择器）

Selector 是 NIO 的多路复用核心，允许单线程监听多个 Channel 的事件。

Selector 的使用流程：

Selector selector = Selector.open(); // 创建 Selector
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT); // 注册 ACCEPT 事件

while (true) {
    int readyChannels = selector.select(); // 阻塞等待就绪事件
    if (readyChannels == 0) continue;

    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        if (key.isAcceptable()) {
            // 处理新连接
            SocketChannel clientChannel = serverChannel.accept();
            clientChannel.configureBlocking(false);
            clientChannel.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            // 处理读事件
            SocketChannel channel = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            channel.read(buffer);
            buffer.flip();
            System.out.println("Received: " + new String(buffer.array()));
        }
        keyIterator.remove(); // 移除已处理的事件
    }
}

Selector 监听的事件类型：

4. NIO 的零拷贝优化

Java NIO 通过 FileChannel 提供两种零拷贝机制：

(1) mmap（内存映射文件）

• 将文件直接映射到进程的虚拟内存，用户态可直接访问。
• 适用于文件随机读写（如 Kafka 的日志存储）。

示例：

RandomAccessFile file = new RandomAccessFile("data.txt", "rw");
FileChannel channel = file.getChannel();
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, channel.size());
buffer.put("New Data".getBytes()); // 直接修改内存，无需 write()

(2) sendfile（文件到网络的零拷贝）

• 通过 FileChannel.transferTo() 直接传输文件到网络，避免用户态拷贝。
• 适用于大文件传输（如 Kafka Broker 发送消息给 Consumer）。

示例：

FileChannel fileChannel = new FileInputStream("data.log").getChannel();
SocketChannel socketChannel = SocketChannel.open();
fileChannel.transferTo(0, fileChannel.size(), socketChannel); // 零拷贝发送

5. NIO 的线程模型

NIO 通常结合 Reactor 模式 实现高并发：

(1) 单 Reactor 单线程

• 1 个 Selector 线程 处理所有 I/O 事件（连接、读、写）。
• 问题：业务逻辑阻塞会影响整个系统（如 Redis）。

(2) 单 Reactor 多线程（Kafka 采用）

• 1 个 Selector 线程 负责 I/O 事件分发。
• Worker 线程池 处理业务逻辑（如消息解码、存储）。
• 优势：避免 I/O 线程被阻塞。

(3) 主从 Reactor 多线程（Netty 采用）

• Main Reactor：处理新连接（OP_ACCEPT）。
• Sub Reactor：处理已建立连接的 I/O 事件（OP_READ/OP_WRITE）。
• Worker 线程池：执行业务逻辑。

6. NIO vs. BIO

7. 总结

• Java NIO 的核心：Channel + Buffer + Selector，实现非阻塞 I/O。
• 高性能关键：
• 多路复用（单线程管理多个连接）。
• 零拷贝（mmap 和 sendfile 减少数据拷贝）。
• 直接内存（DirectByteBuffer 减少 GC 开销）。
• 适用场景：
• Kafka：网络通信（Selector） + 文件存储（mmap）。
• Netty：基于 NIO 的高性能网络框架。
• 高并发服务器（如游戏服务器、RPC 框架）。