NIO（Non-blocking I/O）处理机制

典型的 NIO 事件处理流程

在 Java NIO (Non-blocking I/O) 中，事件驱动模型使得应用程序能够高效地管理多个并发的 I/O 操作。通过 Selector，NIO 使得单个线程可以监听多个通道的事件（如连接请求、读写数据）。以下是对典型 NIO 事件处理流程的详细讲解，包括 Java 代码示例和 UML 时序图。

NIO 事件处理的基本步骤：

初始化 Selector：
- 创建一个 Selector，用于管理多个通道（Channel）和它们的事件。
注册通道：
- 通过 ServerSocketChannel 或 SocketChannel 监听 I/O 事件，并将它们注册到 Selector 上，指定感兴趣的事件类型（如：OP_ACCEPT, OP_READ, OP_WRITE）。
轮询事件：
- Selector.select() 方法阻塞，直到至少有一个通道的事件已经准备好。
事件处理：
- 处理已准备好的事件（如连接请求、读取数据等）。每当事件发生时，Selector 会返回相关通道和事件的集合，应用程序根据事件类型进行处理。
数据读写：
- 对于读写事件，SocketChannel 会被用来进行数据的读取和写入。如果事件是连接请求（OP_ACCEPT），ServerSocketChannel 会接受连接并返回新的 SocketChannel。
关闭通道或重新注册：
- 处理完事件后，如果通道不再需要，应该关闭它，释放相关资源；或者根据需求，将通道重新注册到 Selector 上以处理其他事件。

示例场景：TCP 服务端处理客户端连接

以下示例展示了一个简单的 TCP 服务端，使用 NIO 处理多个客户端的连接请求，并对数据进行读写。

关键类：

ServerSocketChannel：用于监听客户端的连接请求。
SocketChannel：与客户端建立连接后，用于进行数据读写。
Selector：管理多个通道的事件。

事件处理流程：

客户端连接请求。
ServerSocketChannel 注册 OP_ACCEPT 事件。
Selector.select() 阻塞，等待事件。
Selector 发现 OP_ACCEPT 事件，通知 ServerSocketChannel。
ServerSocketChannel 接受连接，并创建 SocketChannel。
SocketChannel 注册 OP_READ 事件。
Selector.select() 阻塞，等待 OP_READ 事件。
客户端发送数据，Selector 检测到 OP_READ 事件，通知 SocketChannel 进行读取。
SocketChannel 读取数据并处理，然后可以注册 OP_WRITE 事件以进行回写。

Java 代码实现：

java 复制代码

import java.io.IOException;
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.net.InetSocketAddress;
import java.util.Iterator;
import java.util.Set;

public class NioServer {

    public static void main(String[] args) throws IOException {
        // 创建 Selector
        Selector selector = Selector.open();
        
        // 创建 ServerSocketChannel 并绑定端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式
        
        // 注册 ServerSocketChannel，感兴趣的事件是 OP_ACCEPT（接受连接事件）
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

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

        while (true) {
            // 阻塞，等待事件发生
            selector.select();

            // 获取已准备好的事件
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectedKeys.iterator();

            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();

                // 处理 OP_ACCEPT 事件（客户端连接请求）
                if (key.isAcceptable()) {
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = serverChannel.accept(); // 接受连接
                    clientChannel.configureBlocking(false); // 设置为非阻塞模式
                    System.out.println("Accepted connection from: " + clientChannel.getRemoteAddress());

                    // 注册客户端通道，感兴趣的事件是 OP_READ（读事件）
                    clientChannel.register(selector, SelectionKey.OP_READ);
                }

                // 处理 OP_READ 事件（读取客户端数据）
                if (key.isReadable()) {
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(256);

                    int bytesRead = clientChannel.read(buffer);
                    if (bytesRead == -1) {
                        // 客户端关闭了连接
                        clientChannel.close();
                    } else {
                        // 处理接收到的数据
                        buffer.flip();
                        System.out.println("Received: " + new String(buffer.array(), 0, bytesRead));

                        // 进行数据处理后，可以注册 OP_WRITE 事件发送数据
                        clientChannel.register(selector, SelectionKey.OP_WRITE);
                    }
                }

                // 处理 OP_WRITE 事件（写数据回客户端）
                if (key.isWritable()) {
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.wrap("Hello from server!".getBytes());
                    clientChannel.write(buffer);
                    System.out.println("Sent response to client.");

                    // 发送完数据后，可以选择关闭通道或继续读取
                    clientChannel.close();
                }
            }
        }
    }
}

代码解释：

Selector 和通道初始化：
- 创建了一个 Selector，用于管理 I/O 事件。
- 使用 ServerSocketChannel 绑定端口 8080，并将其配置为非阻塞模式。
- 通过 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT) 注册了 OP_ACCEPT 事件，表示服务器正在监听客户端的连接。
轮询事件：
- 使用 selector.select() 阻塞，等待 I/O 事件的发生。事件发生时，会返回一个包含已就绪事件的集合。
处理客户端连接请求（OP_ACCEPT）：
- 当客户端连接到服务器时，ServerSocketChannel 会接受连接，并返回一个 SocketChannel，用于与客户端通信。
- 新建立的 SocketChannel 会注册 OP_READ 事件，表示准备读取客户端的数据。
处理读事件（OP_READ）：
- 通过 SocketChannel 读取客户端发送的数据，并根据需要进行处理（例如：打印到控制台）。
处理写事件（OP_WRITE）：
- 将数据写回客户端，完成请求的响应。
关闭连接：
- 发送完数据后，可以选择关闭通道，释放资源。

UML 时序图

Client ServerSocketChannel Selector SocketChannel 发送连接请求注册 OP_ACCEPT 事件轮询到 OP_ACCEPT 事件接受连接，返回新的 SocketChannel 注册 OP_READ 事件轮询到 OP_READ 事件发送数据读取数据处理并回写数据 Client ServerSocketChannel Selector SocketChannel

关键点：

非阻塞 I/O ：NIO 的核心在于非阻塞 I/O，通过 select() 轮询多个通道，使得一个线程能够高效地管理多个连接。
事件驱动模型：通过事件注册和轮询，NIO 可以高效地处理多个客户端连接的 I/O 操作。
适用场景：适用于高并发的网络服务，如聊天室、游戏服务器等。

总结：

NIO 的核心优势 在于通过 Selector 的事件轮询，可以减少线程的创建与切换，提高系统并发处理能力。
在 NIO 中，通道与 Selector 的配合使用使得事件处理变得清晰且高效。