Java NIO I/O 多路复用详解-优快云博客

本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148857288

Java NIO（New I/O）是从Java 1.4版本开始引入的一套新的I/O API，它提供了与标准I/O不同的工作方式，主要区别在于NIO采用了非阻塞和I/O多路复用的机制，能够更高效地处理大量并发连接。下面我将详细解释Java NIO中的I/O多路复用机制。

核心概念

Java NIO的I/O多路复用基于以下几个核心组件：

Channel（通道）
类似于传统I/O中的流（Stream），但支持双向读写，且可以异步操作。常见的Channel实现有：
- FileChannel：用于文件操作
- SocketChannel：用于TCP客户端
- ServerSocketChannel：用于TCP服务器
- DatagramChannel：用于UDP通信
Buffer（缓冲区）
数据的读写操作都是通过Buffer进行的。Buffer本质上是一块内存区域，支持高效的数据存取操作。常见的Buffer类型有：ByteBuffer、CharBuffer、IntBuffer等。
Selector（选择器）
这是I/O多路复用的核心组件，它允许一个线程同时监视多个Channel的I/O事件（如连接就绪、读就绪、写就绪等）。Selector通过轮询的方式检查这些事件，并将就绪的事件通知给应用程序处理。
SelectionKey（选择键）
表示一个Channel和一个Selector之间的注册关系，包含了事件类型（如OP_READ、OP_WRITE等）和对应的Channel引用。

I/O多路复用的工作流程

I/O多路复用的核心思想是：通过一个Selector管理多个Channel，轮询检测哪些Channel有就绪的I/O事件，然后集中处理这些事件。具体工作流程如下：

创建Selector
通过Selector.open()方法创建一个Selector实例。
创建并配置Channel
创建需要的Channel（如ServerSocketChannel或SocketChannel），并将其配置为非阻塞模式：
```
channel.configureBlocking(false);
```
注册Channel到Selector
将Channel注册到Selector，并指定需要监听的事件类型（如SelectionKey.OP_ACCEPT、SelectionKey.OP_READ等）：
```
channel.register(selector, SelectionKey.OP_ACCEPT);
```
轮询就绪事件
通过selector.select()方法阻塞等待，直到有至少一个Channel有就绪事件：
```
int readyChannels = selector.select();
```

处理就绪事件
获取所有就绪的SelectionKey，遍历并处理对应的事件：

Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

while (keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    
    if (key.isAcceptable()) {
        // 处理连接接受事件
    } else if (key.isReadable()) {
        // 处理读事件
    } else if (key.isWritable()) {
        // 处理写事件
    }
    
    keyIterator.remove(); // 处理完后移除key
}

示例代码：基于Selector的简单服务器

下面是一个使用Java NIO实现的简单服务器示例，展示了I/O多路复用的工作方式：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NioServer {
    private static final int PORT = 8080;
    private static final int BUFFER_SIZE = 1024;

    public static void main(String[] args) {
        try (Selector selector = Selector.open();
             ServerSocketChannel serverChannel = ServerSocketChannel.open()) {
            
            // 配置服务器Channel
            serverChannel.bind(new InetSocketAddress(PORT));
            serverChannel.configureBlocking(false);
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            
            System.out.println("服务器启动，监听端口: " + PORT);
            
            // 轮询就绪事件
            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()) {
                        // 处理新连接
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        SocketChannel client = server.accept();
                        System.out.println("新连接: " + client.getRemoteAddress());
                        
                        // 配置客户端Channel为非阻塞模式，并注册读事件
                        client.configureBlocking(false);
                        client.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(BUFFER_SIZE));
                    } 
                    else if (key.isReadable()) {
                        // 处理读事件
                        SocketChannel client = (SocketChannel) key.channel();
                        ByteBuffer buffer = (ByteBuffer) key.attachment();
                        
                        try {
                            int bytesRead = client.read(buffer);
                            if (bytesRead == -1) {
                                // 客户端关闭连接
                                System.out.println("连接关闭: " + client.getRemoteAddress());
                                client.close();
                            } else if (bytesRead > 0) {
                                // 读取数据并回显
                                buffer.flip();
                                byte[] data = new byte[buffer.remaining()];
                                buffer.get(data);
                                String message = new String(data);
                                System.out.println("收到消息: " + message + " 来自: " + client.getRemoteAddress());
                                
                                // 注册写事件，准备回显数据
                                key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
                            }
                        } catch (IOException e) {
                            // 处理异常
                            System.out.println("处理客户端异常: " + client.getRemoteAddress());
                            key.cancel();
                            client.close();
                        }
                    }
                    else if (key.isWritable()) {
                        // 处理写事件
                        SocketChannel client = (SocketChannel) key.channel();
                        ByteBuffer buffer = (ByteBuffer) key.attachment();
                        
                        buffer.flip(); // 切换为读模式
                        client.write(buffer);
                        
                        if (!buffer.hasRemaining()) {
                            // 数据全部写出，取消写事件注册
                            key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
                            buffer.clear(); // 清空缓冲区，准备下次读取
                        }
                    }
                    
                    keyIterator.remove(); // 移除已处理的key
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}