当前位置： 首页 > news >正文

从阻塞到异步：Java IO 模型进化史 ——BIO、NIO、AIO 深度解析

news 2025/8/17 15:07:11

在 Java 开发领域，IO 操作始终是性能优化的核心战场。无论是处理网络请求、读写文件还是操作数据库，IO 模型的选择直接决定了程序的并发能力、响应速度和资源利用率。从最初的 BIO 到高性能的 NIO，再到异步非阻塞的 AIO，Java IO 模型经历了三次重要进化。本文将带你全面剖析这三种 IO 模型的底层原理、核心组件、实现方式及适用场景，通过完整实例代码展示它们的实际应用，帮你在不同业务场景中做出最优技术选型。

一、IO 模型基础：理解阻塞与非阻塞的本质

在深入讲解 BIO、NIO、AIO 之前，我们需要先明确几个关键概念，这些概念是理解所有 IO 模型的基础。IO 操作的本质是数据在内存与外部设备（磁盘、网络等）之间的传输，这个过程涉及两个核心阶段：

等待数据就绪：外部设备准备好数据（如网络数据到达内核缓冲区、磁盘文件数据加载到内存）的过程，这个阶段通常由操作系统内核处理。

数据复制：将准备好的数据从内核缓冲区复制到用户进程内存空间的过程，这个阶段需要用户进程参与。

根据这两个阶段的处理方式不同，IO 模型可分为阻塞和非阻塞两大类，具体又衍生出同步阻塞、同步非阻塞、异步阻塞（无实际意义）、异步非阻塞四种组合。Java 的 BIO、NIO、AIO 分别对应了这三类典型模型：

  • BIO（Blocking IO）：同步阻塞 IO 模型
  • NIO（Non-blocking IO）：同步非阻塞 IO 模型（Java NIO 实际是 New IO，包含非阻塞特性）
  • AIO（Asynchronous IO）：异步非阻塞 IO 模型

在实际应用中，IO 模型的选择需要结合业务场景的并发量、数据处理复杂度、响应时间要求等因素综合判断。接下来我们将逐一解析这三种模型的具体实现。

二、BIO：同步阻塞 IO 的原理与实践

2.1 BIO 模型的核心特点

BIO（Blocking IO）是 Java 最早提供的 IO 模型，全称同步阻塞 IO。在 BIO 模型中，当用户进程发起 IO 操作后，会全程阻塞直到整个 IO 过程完成（包括等待数据就绪和数据复制两个阶段）。在阻塞期间，进程无法进行其他任务，只能等待 IO 操作结束。

BIO 模型的核心特点可总结为：

  • 同步性：IO 操作的发起和结果处理在同一个线程中完成
  • 阻塞性：IO 调用会阻塞线程直到操作完成
  • 简单直观：编程模型简单，易于理解和实现
  • 资源密集：每个连接需要独立线程维护，高并发场景下资源消耗大

2.2 BIO 的核心组件与工作流程

BIO 模型在 Java 中的实现主要依赖于java.net包下的ServerSocket（服务器端）和Socket（客户端）类，文件 IO 则依赖java.io包下的InputStream和OutputStream等类。

BIO 网络通信的典型工作流程：

  1. 服务器启动ServerSocket并绑定端口，调用accept()方法监听客户端连接（此方法会阻塞）
  2. 客户端通过Socket发起连接请求，与服务器建立 TCP 连接
  3. 服务器accept()方法返回客户端Socket对象，创建新线程处理该客户端的 IO 操作
  4. 线程通过Socket的输入流读取数据（读操作会阻塞），处理后通过输出流写入响应（写操作在缓冲区满时会阻塞）
  5. 客户端读取响应数据，完成一次通信
  6. 连接关闭，线程释放资源

2.3 BIO 实例：echo 服务器的实现与问题分析

2.3.1 单线程 BIO 服务器（性能极差）

java

package com.io.bio;import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;/*** 单线程BIO服务器示例* 缺陷：同一时间只能处理一个客户端连接，其他连接需排队等待*/
@Slf4j
public class SingleThreadBioServer {public static void main(String[] args) {// 定义服务器端口int port = 8080;ServerSocket serverSocket = null;try {// 创建ServerSocket并绑定端口serverSocket = new ServerSocket(port);log.info("BIO服务器启动成功，监听端口：{}", port);// 循环监听客户端连接（服务器主循环）while (true) {// 阻塞等待客户端连接（关键点：此方法会一直阻塞直到有新连接）Socket clientSocket = serverSocket.accept();log.info("新客户端连接：{}:{}", clientSocket.getInetAddress().getHostAddress(), clientSocket.getPort());// 处理客户端请求（单线程模式下，处理期间无法接收新连接）handleClient(clientSocket);}} catch (IOException e) {log.error("服务器异常", e);} finally {// 关闭服务器Socketif (serverSocket != null) {try {serverSocket.close();log.info("服务器已关闭");} catch (IOException e) {log.error("关闭服务器异常", e);}}}}/*** 处理客户端请求*/private static void handleClient(Socket clientSocket) {try (// 获取输入流（读取客户端数据）InputStream in = clientSocket.getInputStream();// 获取输出流（向客户端写数据）OutputStream out = clientSocket.getOutputStream()) {byte[] buffer = new byte[1024];int length;// 循环读取客户端数据（关键点：read方法会阻塞直到有数据可读）while ((length = in.read(buffer)) != -1) {String message = new String(buffer, 0, length);log.info("收到客户端消息：{}", message);// 模拟业务处理耗时（实际场景可能是数据库操作等）Thread.sleep(100);// 将收到的消息原样返回（echo功能）out.write(buffer, 0, length);out.flush(); // 强制刷新缓冲区log.info("已向客户端返回消息");}} catch (IOException e) {log.error("处理客户端IO异常", e);} catch (InterruptedException e) {log.error("线程休眠异常", e);Thread.currentThread().interrupt(); // 恢复中断状态} finally {// 关闭客户端Sockettry {clientSocket.close();log.info("客户端连接已关闭");} catch (IOException e) {log.error("关闭客户端连接异常", e);}}}
}

单线程 BIO 的致命问题：当服务器正在处理一个客户端请求时（无论是等待数据还是处理数据），无法接收其他客户端的连接请求，所有新连接都会被阻塞在accept()方法处。这导致服务器的并发能力为 1，完全无法满足实际应用需求。

2.3.2 多线程 BIO 服务器（线程爆炸风险）

为解决单线程的并发问题，最直接的方案是为每个客户端连接创建独立线程处理。

java

package com.io.bio;import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;/*** 多线程BIO服务器示例* 改进：为每个客户端连接创建独立线程处理，支持并发连接* 缺陷：高并发下线程数量激增，导致资源耗尽*/
@Slf4j
public class MultiThreadBioServer {public static void main(String[] args) {int port = 8080;ServerSocket serverSocket = null;try {serverSocket = new ServerSocket(port);log.info("多线程BIO服务器启动成功，监听端口：{}", port);while (true) {// 阻塞等待客户端连接Socket clientSocket = serverSocket.accept();log.info("新客户端连接：{}:{}", clientSocket.getInetAddress().getHostAddress(), clientSocket.getPort());// 关键点：为每个客户端创建新线程处理请求new Thread(() -> handleClient(clientSocket)).start();}} catch (IOException e) {log.error("服务器异常", e);} finally {if (serverSocket != null) {try {serverSocket.close();log.info("服务器已关闭");} catch (IOException e) {log.error("关闭服务器异常", e);}}}}/*** 处理客户端请求（与单线程版本相同）*/private static void handleClient(Socket clientSocket) {// 实现与SingleThreadBioServer的handleClient方法完全相同// 此处省略实现代码以避免重复}
}

多线程 BIO 的问题分析：多线程模型虽然解决了并发问题，但引入了新的挑战：

  • 线程资源消耗：每个线程需要分配栈内存（默认 1MB），大量线程会导致内存消耗激增
  • 上下文切换开销：CPU 在多线程间切换需要保存和恢复线程状态，线程越多切换成本越高
  • 连接效率问题：短连接场景下，线程创建销毁的开销可能超过实际业务处理时间

在实际生产环境中，无限制创建线程的做法极其危险，当并发连接数达到数千时，很容易引发 OOM（内存溢出）或系统崩溃。

2.3.3 线程池优化的 BIO 服务器（有限资源控制）

为解决线程爆炸问题，最佳实践是使用线程池管理线程资源，通过固定数量的线程处理大量客户端连接。

java

package com.io.bio;import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** 线程池优化的BIO服务器* 改进：使用线程池管理线程资源，控制最大并发线程数* 缺陷：连接数超过线程池容量时，新连接会排队等待*/
@Slf4j
public class ThreadPoolBioServer {// 线程池核心参数（根据实际硬件配置调整）private static final int CORE_POOL_SIZE = 10;private static final int MAX_POOL_SIZE = 50;private static final int QUEUE_CAPACITY = 100;private static final long KEEP_ALIVE_TIME = 60;// 创建线程池（符合阿里巴巴Java开发手册规范）private static final ExecutorService threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME,TimeUnit.SECONDS,new ArrayBlockingQueue<>(QUEUE_CAPACITY),new ThreadPoolExecutor.CallerRunsPolicy() // 队列满时的拒绝策略);public static void main(String[] args) {int port = 8080;ServerSocket serverSocket = null;try {serverSocket = new ServerSocket(port);log.info("线程池优化BIO服务器启动成功，监听端口：{}", port);log.info("线程池配置：核心线程数={}, 最大线程数={}, 队列容量={}",CORE_POOL_SIZE, MAX_POOL_SIZE, QUEUE_CAPACITY);while (true) {// 阻塞等待客户端连接Socket clientSocket = serverSocket.accept();log.info("新客户端连接：{}:{}", clientSocket.getInetAddress().getHostAddress(), clientSocket.getPort());// 关键点：提交任务到线程池处理threadPool.execute(() -> handleClient(clientSocket));}} catch (IOException e) {log.error("服务器异常", e);} finally {if (serverSocket != null) {try {serverSocket.close();log.info("服务器已关闭");} catch (IOException e) {log.error("关闭服务器异常", e);}}// 关闭线程池threadPool.shutdown();try {if (!threadPool.awaitTermination(5, TimeUnit.SECONDS)) {threadPool.shutdownNow();}log.info("线程池已关闭");} catch (InterruptedException e) {threadPool.shutdownNow();Thread.currentThread().interrupt();}}}/*** 处理客户端请求（与前面版本相同）*/private static void handleClient(Socket clientSocket) {// 实现与SingleThreadBioServer的handleClient方法完全相同// 此处省略实现代码以避免重复}
}

线程池 BIO 的优势与局限：线程池通过控制最大线程数量解决了资源耗尽问题，同时通过线程复用减少了线程创建销毁的开销。但这种模型仍存在根本局限：

  • 当并发连接数超过线程池最大容量（最大线程数 + 队列容量）时，新连接会被拒绝或排队
  • 线程在等待 IO 操作（read()/write()）时仍然处于阻塞状态，无法处理其他任务
  • 每个连接仍需要占用一个线程，在高并发场景下（如 10 万级连接）仍不可行

2.4 BIO 的适用场景与最佳实践

尽管 BIO 存在性能局限，但在特定场景下仍是合适的选择：

BIO 适用场景：

  • 连接数较少且固定的场景（如内部管理系统）
  • 单个连接的 IO 操作时间较长的场景（如文件传输）
  • 对实时性要求不高，开发成本优先于性能的场景

BIO 最佳实践：

  1. 必须使用线程池管理线程资源，严禁无限制创建线程
  2. 合理配置线程池参数（核心线程数、最大线程数、队列容量），需进行压测验证
  3. 设置合理的 IO 超时时间，避免线程永久阻塞
  4. 短连接场景下可使用长连接复用减少连接建立开销
  5. 关键业务需监控线程池状态（活跃线程数、队列长度等）

BIO 模型的核心问题在于阻塞导致的线程资源浪费，为解决这个问题，Java 在 JDK 1.4 中引入了 NIO（New IO）模型，彻底改变了 IO 操作的处理方式。

三、NIO：同步非阻塞 IO 的高性能之道

3.1 NIO 模型的核心突破

NIO（New IO）是 Java 1.4 引入的新 IO 模型，其核心是同步非阻塞特性。与 BIO 的全程阻塞不同，NIO 允许用户进程在 IO 操作等待数据就绪阶段不阻塞，而是可以去处理其他任务，当数据就绪后再进行数据复制操作。

NIO 的核心优势可总结为：

  • 非阻塞性：IO 操作等待数据阶段不会阻塞线程
  • 多路复用：单线程可同时管理多个 IO 通道
  • 缓冲区导向：数据读写基于缓冲区，减少内存复制
  • 事件驱动：基于事件通知机制处理 IO 就绪事件

NIO 模型的引入使 Java 能够处理高并发场景，理论上单个线程可支持成千上万的并发连接，这是 BIO 无法实现的突破。

3.2 NIO 的三大核心组件

NIO 模型通过三个核心组件实现非阻塞 IO 操作：Buffer（缓冲区）、Channel（通道） 和Selector（选择器），三者协同工作构成 NIO 的基础架构。

3.2.1 Buffer：数据容器与操作机制

Buffer 是 NIO 中数据存储的容器，所有 IO 操作都通过 Buffer 进行。与 BIO 的流（Stream）不同，Buffer 是一块连续的内存区域，支持随机访问，数据读写具有明确的边界。

Buffer 的核心属性：

  • capacity：缓冲区容量，创建后不可更改
  • position：当前读写位置，随读写操作移动
  • limit：读写限制位置，标识有效数据边界
  • mark：标记位置，用于临时保存 position 以便后续重置

常用 Buffer 类型：

  • ByteBuffer：最常用的缓冲区类型，用于字节数据
  • CharBuffer/IntBuffer/LongBuffer等：对应基本数据类型的缓冲区
  • MappedByteBuffer：内存映射文件缓冲区，支持直接操作磁盘文件

Buffer 的核心操作流程：

  1. 创建缓冲区（allocate()或allocateDirect()）
  2. 写入数据到缓冲区（put()方法或从 Channel 读取）
  3. 切换到读模式（flip()方法：limit=position，position=0）
  4. 从缓冲区读取数据（get()方法或写入到 Channel）
  5. 清空缓冲区准备下次写入（clear()或compact()）

java

package com.io.nio;import lombok.extern.slf4j.Slf4j;
import java.nio.ByteBuffer;/*** Buffer操作示例* 展示Buffer的创建、写入、切换模式、读取等核心操作*/
@Slf4j
public class BufferExample {public static void main(String[] args) {// 1. 创建缓冲区（容量为1024字节）ByteBuffer buffer = ByteBuffer.allocate(1024);log.info("初始化缓冲区 - capacity: {}, position: {}, limit: {}",buffer.capacity(), buffer.position(), buffer.limit());// 2. 写入数据到缓冲区String message = "Hello NIO Buffer!";buffer.put(message.getBytes());log.info("写入数据后 - capacity: {}, position: {}, limit: {}",buffer.capacity(), buffer.position(), buffer.limit());// 3. 切换到读模式（flip()方法）buffer.flip();log.info("切换到读模式后 - capacity: {}, position: {}, limit: {}",buffer.capacity(), buffer.position(), buffer.limit());// 4. 从缓冲区读取数据byte[] readBytes = new byte[buffer.limit()];buffer.get(readBytes);log.info("读取的数据: {}", new String(readBytes));log.info("读取数据后 - capacity: {}, position: {}, limit: {}",buffer.capacity(), buffer.position(), buffer.limit());// 5. 清空缓冲区（clear()方法：position=0, limit=capacity）buffer.clear();log.info("清空缓冲区后 - capacity: {}, position: {}, limit: {}",buffer.capacity(), buffer.position(), buffer.limit());// 演示compact()方法：保留未读取数据，适合部分读取场景buffer.put("First part ".getBytes());buffer.flip();byte[] partial = new byte[5];buffer.get(partial); // 读取前5个字节log.info("部分读取数据: {}", new String(partial));log.info("部分读取后 - capacity: {}, position: {}, limit: {}",buffer.capacity(), buffer.position(), buffer.limit());buffer.compact(); // 压缩缓冲区：未读取数据移到开头log.info("压缩缓冲区后 - capacity: {}, position: {}, limit: {}",buffer.capacity(), buffer.position(), buffer.limit());buffer.put("Second part".getBytes()); // 继续写入数据buffer.flip();byte[] allData = new byte[buffer.limit()];buffer.get(allData);log.info("完整数据: {}", new String(allData)); // 应包含剩余数据+新数据}
}

直接缓冲区与非直接缓冲区：

  • 非直接缓冲区：通过allocate()创建，位于 JVM 堆内存，受 GC 管理，读写需中间缓冲区
  • 直接缓冲区：通过allocateDirect()创建，位于操作系统内核空间，不受 GC 直接管理，读写效率更高
  • 选择建议：频繁读写的长期存在的缓冲区用直接缓冲区；短期临时缓冲区用非直接缓冲区
3.2.2 Channel：双向数据通道

Channel 是 NIO 中数据传输的通道，与 BIO 的流（Stream）相比，Channel 具有双向性（既可读也可写），且必须与 Buffer 配合使用。

Channel 的核心特点：

  • 双向性：同一 Channel 可同时支持读和写操作
  • 非阻塞：支持非阻塞模式（需配合 Selector）
  • 可中断：Channel 的 IO 操作可被中断
  • 支持并发：可被多个线程安全访问（需同步）

常用 Channel 类型：

  • SocketChannel：TCP 客户端通道
  • ServerSocketChannel：TCP 服务器通道
  • DatagramChannel：UDP 协议通道
  • FileChannel：文件 IO 通道
  • Pipe.SinkChannel/Pipe.SourceChannel：管道通道，用于线程间通信

Channel 的核心操作：

  • read(Buffer)：从通道读取数据到缓冲区
  • write(Buffer)：从缓冲区写入数据到通道
  • configureBlocking(boolean)：设置是否为非阻塞模式
  • register(Selector, int)：向选择器注册通道及关注的事件
3.2.3 Selector：IO 多路复用器

Selector 是 NIO 实现非阻塞 IO 的核心组件，它允许单个线程同时监控多个 Channel 的 IO 事件（如连接就绪、读就绪、写就绪），实现 "一个线程管理多个通道" 的高效 IO 模型。

Selector 的工作原理：

  1. 线程创建 Selector 实例，并将多个 Channel 注册到 Selector
  2. 每个注册的 Channel 需指定关注的 IO 事件类型（SelectionKey）
  3. 线程调用 Selector 的select()方法阻塞等待事件就绪
  4. 当一个或多个 Channel 的 IO 事件就绪时，select()返回就绪事件数量
  5. 线程获取就绪事件集合，遍历处理每个就绪事件
  6. 处理完成后重复步骤 3，进入下一轮事件等待

SelectionKey：事件与通道的关联：

  • OP_ACCEPT：服务器通道接受连接就绪事件（值为 16）
  • OP_CONNECT：客户端通道连接就绪事件（值为 8）
  • OP_READ：通道读就绪事件（值为 1）
  • OP_WRITE：通道写就绪事件（值为 4）

每个 SelectionKey 包含以下核心信息：

  • 对应的 Channel 对象（channel()方法获取）
  • 对应的 Selector 对象（selector()方法获取）
  • 关注的事件集合（interestOps()方法获取）
  • 就绪的事件集合（readyOps()方法获取）
  • 附加对象（attach()/attachment()方法设置和获取）

3.3 NIO 网络编程完整实例

3.3.1 NIO 服务器实现

java

package com.io.nio;import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Set;/*** NIO服务器完整实现* 核心特点：单线程通过Selector管理多个Channel，实现非阻塞IO*/
@Slf4j
public class NioServer {// 缓冲区大小（根据业务场景调整）private static final int BUFFER_SIZE = 1024;// 服务器端口private static final int PORT = 8080;public static void main(String[] args) {Selector selector = null;ServerSocketChannel serverSocketChannel = null;try {// 1. 创建Selectorselector = Selector.open();// 2. 创建ServerSocketChannel并配置serverSocketChannel = ServerSocketChannel.open();// 绑定端口serverSocketChannel.socket().bind(new InetSocketAddress(PORT));// 关键点：设置为非阻塞模式serverSocketChannel.configureBlocking(false);// 3. 向Selector注册ServerSocketChannel，关注ACCEPT事件serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);log.info("NIO服务器启动成功，监听端口：{}", PORT);// 4. 服务器主循环while (true) {// 关键点：阻塞等待就绪事件（select()返回就绪事件数量）// 可使用select(long timeout)设置超时时间，避免永久阻塞int readyChannels = selector.select();if (readyChannels == 0) {continue; // 无就绪事件，继续等待}// 5. 获取就绪事件集合Set<SelectionKey> selectedKeys = selector.selectedKeys();Iterator<SelectionKey> keyIterator = selectedKeys.iterator();// 6. 遍历处理就绪事件while (keyIterator.hasNext()) {SelectionKey key = keyIterator.next();// 移除已处理的key，避免重复处理keyIterator.remove();// 检查事件是否有效（通道是否已关闭等）if (!key.isValid()) {continue;}// 处理ACCEPT事件（新客户端连接）if (key.isAcceptable()) {handleAccept(key, selector);}// 处理READ事件（客户端发送数据）else if (key.isReadable()) {handleRead(key);}// 处理WRITE事件（通道可写入数据）else if (key.isWritable()) {handleWrite(key);}}}} catch (IOException e) {log.error("NIO服务器异常", e);} finally {// 关闭资源if (serverSocketChannel != null) {try {serverSocketChannel.close();} catch (IOException e) {log.error("关闭ServerSocketChannel异常", e);}}if (selector != null) {try {selector.close();} catch (IOException e) {log.error("关闭Selector异常", e);}}log.info("NIO服务器已关闭");}}/*** 处理ACCEPT事件：接受新客户端连接*/private static void handleAccept(SelectionKey key, Selector selector) throws IOException {// 获取ServerSocketChannelServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();// 接受客户端连接（非阻塞模式下，此处不会阻塞）SocketChannel clientChannel = serverSocketChannel.accept();if (clientChannel == null) {return; // 非阻塞模式下可能返回null}log.info("新客户端连接：{}:{}",clientChannel.socket().getInetAddress().getHostAddress(),clientChannel.socket().getPort());// 配置客户端通道为非阻塞模式clientChannel.configureBlocking(false);// 向客户端通道注册Selector，关注READ事件// 附加一个ByteBuffer作为该通道的缓冲区clientChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(BUFFER_SIZE));}/*** 处理READ事件：读取客户端发送的数据*/private static void handleRead(SelectionKey key) throws IOException {// 获取客户端通道SocketChannel clientChannel = (SocketChannel) key.channel();// 获取通道附加的缓冲区ByteBuffer buffer = (ByteBuffer) key.attachment();// 读取数据到缓冲区（非阻塞模式下，read返回-1表示连接关闭）int bytesRead = clientChannel.read(buffer);if (bytesRead > 0) {// 切换到读模式buffer.flip();// 读取缓冲区数据byte[] bytes = new byte[buffer.remaining()];buffer.get(bytes);String message = new String(bytes, StandardCharsets.UTF_8);log.info("收到客户端消息：{}", message);// 准备响应数据String response = "服务器已收到：" + message;ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes(StandardCharsets.UTF_8));// 尝试直接写入响应int bytesWritten = clientChannel.write(responseBuffer);if (bytesWritten < responseBuffer.capacity()) {// 未能写完所有数据，需要注册WRITE事件继续写入// 将未写完的缓冲区附加到SelectionKeykey.attach(responseBuffer);// 更新关注的事件：保留READ事件，添加WRITE事件key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);} else {// 数据已写完，继续关注READ事件buffer.clear();key.attach(buffer);key.interestOps(SelectionKey.OP_READ);}} else if (bytesRead < 0) {// 客户端关闭连接log.info("客户端断开连接：{}:{}",clientChannel.socket().getInetAddress().getHostAddress(),clientChannel.socket().getPort());key.cancel(); // 取消注册clientChannel.close(); // 关闭通道} else {// bytesRead == 0：非阻塞模式下无数据可读// 无需处理，继续关注READ事件}}/*** 处理WRITE事件：继续写入未完成的数据*/private static void handleWrite(SelectionKey key) throws IOException {// 获取客户端通道SocketChannel clientChannel = (SocketChannel) key.channel();// 获取未写完的缓冲区ByteBuffer buffer = (ByteBuffer) key.attachment();// 继续写入数据clientChannel.write(buffer);if (!buffer.hasRemaining()) {// 数据已写完，取消WRITE事件关注，保留READ事件buffer.clear();key.attach(ByteBuffer.allocate(BUFFER_SIZE)); // 重置缓冲区key.interestOps(SelectionKey.OP_READ);log.info("响应数据已全部发送");}}
}
3.3.2 NIO 客户端实现

java

package com.io.nio;import lombok.extern.slf4j.Slf4j;
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.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;/*** NIO客户端实现* 支持与服务器交互，可输入消息并接收响应*/
@Slf4j
public class NioClient {private static final int BUFFER_SIZE = 1024;private static final String SERVER_HOST = "localhost";private static final int SERVER_PORT = 8080;public static void main(String[] args) {Selector selector = null;SocketChannel socketChannel = null;try {// 创建Selectorselector = Selector.open();// 创建SocketChannel并配置socketChannel = SocketChannel.open();socketChannel.configureBlocking(false); // 非阻塞模式// 连接服务器（非阻塞模式下，connect()会立即返回）socketChannel.connect(new InetSocketAddress(SERVER_HOST, SERVER_PORT));// 注册连接事件socketChannel.register(selector, SelectionKey.OP_CONNECT);log.info("客户端启动成功，正在连接服务器...");// 启动用户输入线程startInputThread(socketChannel);// 客户端主循环while (true) {// 等待就绪事件selector.select();// 处理就绪事件Set<SelectionKey> selectedKeys = selector.selectedKeys();Iterator<SelectionKey> keyIterator = selectedKeys.iterator();while (keyIterator.hasNext()) {SelectionKey key = keyIterator.next();keyIterator.remove();if (!key.isValid()) {continue;}// 处理连接就绪事件if (key.isConnectable()) {handleConnect(key, selector);}// 处理读就绪事件（接收服务器响应）else if (key.isReadable()) {handleRead(key);}// 处理写就绪事件（发送数据）else if (key.isWritable()) {handleWrite(key);}}}} catch (IOException e) {log.error("NIO客户端异常", e);} finally {// 关闭资源if (socketChannel != null) {try {socketChannel.close();} catch (IOException e) {log.error("关闭SocketChannel异常", e);}}if (selector != null) {try {selector.close();} catch (IOException e) {log.error("关闭Selector异常", e);}}log.info("NIO客户端已关闭");}}/*** 处理连接就绪事件*/private static void handleConnect(SelectionKey key, Selector selector) throws IOException {SocketChannel clientChannel = (SocketChannel) key.channel();// 完成连接过程if (clientChannel.finishConnect()) {log.info("已成功连接到服务器");// 连接成功后，注册读事件，准备接收服务器响应clientChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(BUFFER_SIZE));} else {// 连接失败，关闭通道log.error("连接服务器失败");key.cancel();clientChannel.close();}}/*** 处理读事件：接收服务器响应*/private static void handleRead(SelectionKey key) throws IOException {SocketChannel clientChannel = (SocketChannel) key.channel();ByteBuffer buffer = (ByteBuffer) key.attachment();int bytesRead = clientChannel.read(buffer);if (bytesRead > 0) {buffer.flip();byte[] bytes = new byte[buffer.remaining()];buffer.get(bytes);String response = new String(bytes, StandardCharsets.UTF_8);log.info("收到服务器响应：{}", response);// 重置缓冲区，继续关注读事件buffer.clear();key.attach(buffer);} else if (bytesRead < 0) {// 服务器关闭连接log.info("服务器已断开连接");key.cancel();clientChannel.close();System.exit(0); // 退出客户端}}/*** 处理写事件：发送数据到服务器*/private static void handleWrite(SelectionKey key) throws IOException {SocketChannel clientChannel = (SocketChannel) key.channel();// 获取待发送的缓冲区（由输入线程设置）ByteBuffer buffer = (ByteBuffer) key.attachment();// 发送数据clientChannel.write(buffer);if (!buffer.hasRemaining()) {// 数据发送完成，取消写事件关注，保留读事件buffer.clear();key.interestOps(SelectionKey.OP_READ);log.info("消息已发送");}}/*** 启动用户输入线程，读取控制台输入并发送到服务器*/private static void startInputThread(SocketChannel socketChannel) {Thread inputThread = new Thread(() -> {Scanner scanner = new Scanner(System.in);try {while (true) {System.out.print("请输入消息（输入exit退出）：");String message = scanner.nextLine();if ("exit".equalsIgnoreCase(message)) {log.info("客户端准备退出");socketChannel.close();System.exit(0);}// 等待通道可写while (!socketChannel.isOpen()) {Thread.sleep(100);}// 准备数据并注册写事件ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));SelectionKey key = socketChannel.keyFor(socketChannel.selector());if (key != null) {// 附加缓冲区并注册写事件key.attach(buffer);key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);// 唤醒SelectorsocketChannel.selector().wakeup();}}} catch (IOException e) {log.error("发送消息异常", e);} catch (InterruptedException e) {log.error("输入线程被中断", e);Thread.currentThread().interrupt();} finally {scanner.close();}}, "Input-Thread");inputThread.setDaemon(true); // 设置为守护线程inputThread.start();}
}

3.4 NIO 的高级特性：Pipe 与 FileChannel

除了网络 IO，NIO 还提供了高效的文件 IO 和线程间通信能力，这也是 NIO 相比传统 IO 的重要优势。

3.4.1 Pipe：线程间通信通道

Pipe 是 NIO 提供的用于同一 JVM 内线程间通信的通道，由一个 SinkChannel（写入端）和一个 SourceChannel（读取端）组成。

java

package com.io.nio;import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;
import java.nio.charset.StandardCharsets;/*** Pipe示例：展示线程间通过Pipe通信*/
@Slf4j
public class PipeExample {public static void main(String[] args) throws IOException {// 创建PipePipe pipe = Pipe.open();// 创建写入线程Thread writerThread = new Thread(() -> {try {// 获取SinkChannel（写入端）Pipe.SinkChannel sinkChannel = pipe.sink();// 配置为非阻塞模式sinkChannel.configureBlocking(false);// 发送消息for (int i = 1; i <= 5; i++) {String message = "Pipe消息 " + i;ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));// 写入数据while (sinkChannel.write(buffer) == 0) {// 通道暂时不可写，短暂等待Thread.sleep(100);}log.info("写入线程发送：{}", message);Thread.sleep(1000); // 模拟间隔}// 关闭写入端sinkChannel.close();log.info("写入线程已关闭");} catch (IOException e) {log.error("写入线程IO异常", e);} catch (InterruptedException e) {log.error("写入线程被中断", e);Thread.currentThread().interrupt();}}, "Writer-Thread");// 创建读取线程Thread readerThread = new Thread(() -> {try {// 获取SourceChannel（读取端）Pipe.SourceChannel sourceChannel = pipe.source();// 配置为非阻塞模式sourceChannel.configureBlocking(false);ByteBuffer buffer = ByteBuffer.allocate(1024);// 读取消息while (sourceChannel.isOpen()) {int bytesRead = sourceChannel.read(buffer);if (bytesRead > 0) {buffer.flip();byte[] bytes = new byte[buffer.remaining()];buffer.get(bytes);log.info("读取线程接收：{}", new String(bytes, StandardCharsets.UTF_8));buffer.clear();} else if (bytesRead < 0) {// 通道已关闭break;} else {// 无数据可读，短暂等待Thread.sleep(100);}}// 关闭读取端sourceChannel.close();log.info("读取线程已关闭");} catch (IOException e) {log.error("读取线程IO异常", e);} catch (InterruptedException e) {log.error("读取线程被中断", e);Thread.currentThread().interrupt();}}, "Reader-Thread");// 启动线程writerThread.start();readerThread.start();}
}
3.4.2 FileChannel：高效文件操作

FileChannel 提供了高效的文件 IO 操作，支持内存映射、文件锁定、零拷贝等高级特性，性能远超传统的 FileInputStream/FileOutputStream。

java

package com.io.nio;import lombok.extern.slf4j.Slf4j;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;/*** FileChannel示例：展示高效文件操作*/
@Slf4j
public class FileChannelExample {private static final String FILE_PATH = "nio_file_demo.txt";private static final String LARGE_FILE_PATH = "large_file_copy_demo.dat";public static void main(String[] args) {try {// 演示基本文件写入writeToFile();// 演示文件读取readFromFile();// 演示文件复制（零拷贝）copyFileWithZeroCopy();// 演示内存映射文件memoryMappedFileOperation();log.info("所有文件操作完成");} catch (IOException e) {log.error("文件操作异常", e);} finally {// 清理测试文件cleanUpFiles();}}/*** 使用FileChannel写入文件*/private static void writeToFile() throws IOException {// 创建FileChannel（使用RandomAccessFile支持读写）try (FileChannel channel = FileChannel.open(Paths.get(FILE_PATH),EnumSet.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING))) {String content = "Hello FileChannel!\n这是NIO文件操作示例。";ByteBuffer buffer = ByteBuffer.wrap(content.getBytes(StandardCharsets.UTF_8));// 写入数据int bytesWritten = channel.write(buffer);log.info("写入文件完成，写入字节数：{}", bytesWritten);}}/*** 使用FileChannel读取文件*/private static void readFromFile() throws IOException {try (FileChannel channel = FileChannel.open(Paths.get(FILE_PATH),StandardOpenOption.READ)) {// 获取文件大小long fileSize = channel.size();log.info("文件大小：{}字节", fileSize);// 创建缓冲区ByteBuffer buffer = ByteBuffer.allocate((int) fileSize);// 读取文件内容channel.read(buffer);buffer.flip();// 转换为字符串String content = new String(buffer.array(), 0, buffer.limit(), StandardCharsets.UTF_8);log.info("文件内容：\n{}", content);}}/*** 使用transferTo实现零拷贝文件复制*/private static void copyFileWithZeroCopy() throws IOException {// 创建一个测试大文件（10MB）createTestFile(LARGE_FILE_PATH, 10 * 1024 * 1024);// 源文件通道try (FileChannel sourceChannel = FileChannel.open(Paths.get(LARGE_FILE_PATH),StandardOpenOption.READ);// 目标文件通道FileChannel destChannel = FileChannel.open(Paths.get(LARGE_FILE_PATH + ".copy"),EnumSet.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE))) {long startTime = System.currentTimeMillis();// 零拷贝复制（直接在内核空间传输数据，避免用户态和内核态切换）long position = 0;long remaining = sourceChannel.size();while (remaining > 0) {long transferred = sourceChannel.transferTo(position, remaining, destChannel);if (transferred <= 0) {break; // 传输完成}position += transferred;remaining -= transferred;}long endTime = System.currentTimeMillis();log.info("零拷贝文件复制完成，耗时：{}ms，文件大小：{}MB",endTime - startTime, sourceChannel.size() / (1024 * 1024));}}/*** 内存映射文件操作*/private static void memoryMappedFileOperation() throws IOException {try (RandomAccessFile raf = new RandomAccessFile(FILE_PATH, "rw");FileChannel channel = raf.getChannel()) {// 创建内存映射（直接操作内存映射区域，无需read/write系统调用）MappedByteBuffer mappedBuffer = channel.map(FileChannel.MapMode.READ_WRITE,0,channel.size());log.info("内存映射文件内容：{}", new String(mappedBuffer.array(), 0, mappedBuffer.limit(), StandardCharsets.UTF_8));// 修改内存映射内容（会直接反映到文件）mappedBuffer.position(0); // 移到开头mappedBuffer.put("Modified by MappedByteBuffer!".getBytes(StandardCharsets.UTF_8));// 强制刷新到磁盘mappedBuffer.force();log.info("内存映射文件修改完成");}}/*** 创建指定大小的测试文件*/private static void createTestFile(String path, int size) throws IOException {try (FileChannel channel = FileChannel.open(Paths.get(path),EnumSet.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING))) {// 写入指定大小的随机数据ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 1MB缓冲区byte[] data = new byte[1024 * 1024];new java.util.Random().nextBytes(data);buffer.put(data);int remaining = size;while (remaining > 0) {int writeSize = Math.min(remaining, buffer.capacity());buffer.limit(writeSize);buffer.flip();channel.write(buffer);remaining -= writeSize;buffer.clear();}}}/*** 清理测试文件*/private static void cleanUpFiles() {try {Files.deleteIfExists(Paths.get(FILE_PATH));Files.deleteIfExists(Paths.get(LARGE_FILE_PATH));Files.deleteIfExists(Paths.get(LARGE_FILE_PATH + ".copy"));log.info("测试文件已清理");} catch (IOException e) {log.warn("清理测试文件失败", e);}}
}

3.5 NIO 的适用场景与性能优化

NIO 凭借其非阻塞和多路复用特性，在高并发场景下表现出色，是构建高性能中间件的核心技术。

NIO 适用场景：

  • 高并发网络应用（如 Web 服务器、聊天服务器）
  • 大量并发连接但每个连接数据量小的场景（如即时通讯）
  • 需要高效文件操作的场景（如大文件复制、日志收集）
  • 线程间通信频繁的场景

NIO 性能优化建议：

  1. 合理设置缓冲区大小：过小会导致频繁 IO，过大会浪费内存，通常设置为 512KB~8MB
  2. 优先使用直接缓冲区：对于长期存在的缓冲区，直接缓冲区可减少内存复制
  3. Selector 线程优化：
    • 单 Selector 适用于连接数适中的场景
    • 高并发场景可使用多 Selector，按通道哈希分配
    • 避免在 Selector 线程中执行耗时操作
  4. 事件处理优化：
    • 读写操作尽量一次完成，减少事件触发次数
    • 写操作仅在有数据时注册 WRITE 事件，避免空轮询
  5. 连接管理：
    • 实现连接超时机制，清理无效连接
    • 对长期空闲连接进行心跳检测

四、AIO：异步非阻塞 IO 的未来趋势

4.1 AIO 模型的核心变革

AIO（Asynchronous IO）是 Java 1.7 引入的异步非阻塞 IO 模型，它是对 NIO 的进一步升级。与 NIO 的同步非阻塞不同，AIO 将数据复制阶段也交由操作系统处理，用户进程只需发起 IO 操作并指定回调函数，当整个 IO 过程（包括数据就绪和数据复制）完成后，操作系统会主动通知用户进程并执行回调。

AIO 的核心优势可总结为：

  • 全异步性：整个 IO 过程（等待就绪 + 数据复制）都不需要用户线程参与
  • 零阻塞：用户线程发起 IO 操作后立即返回，无需等待任何阶段
  • 回调驱动：操作完成后通过回调函数或 Future 通知结果
  • 资源高效：无需线程等待 IO，资源利用率更高

AIO 模型彻底解放了用户线程，使其可以专注于业务逻辑处理，而不必关心 IO 操作的具体过程，这是构建高性能 IO 应用的理想模型。

4.2 AIO 的核心组件与工作流程

AIO 模型在 Java 中的实现主要集中在java.nio.channels包下，核心类包括：

  • AsynchronousServerSocketChannel：异步服务器通道，用于监听客户端连接
  • AsynchronousSocketChannel：异步客户端通道，用于与服务器通信
  • CompletionHandler：完成处理器接口，定义 IO 操作完成后的回调方法
  • Future：用于获取异步操作结果的接口

AIO 网络通信的典型工作流程：

  1. 服务器创建AsynchronousServerSocketChannel并绑定端口
  2. 调用accept()方法异步监听客户端连接，指定CompletionHandler
  3. 客户端创建AsynchronousSocketChannel并调用connect()异步连接服务器
  4. 服务器接收到连接请求后，CompletionHandler.completed()方法被回调
  5. 在回调方法中，服务器通过新创建的AsynchronousSocketChannel与客户端通信
  6. 服务器 / 客户端调用read()/write()方法异步读写数据，指定回调函数
  7. 数据读写完成后，相应的回调方法被调用，处理结果
  8. 通信完成后关闭通道

4.3 AIO 的两种编程模式

AIO 提供了两种处理异步操作结果的方式：CompletionHandler 回调模式和Future 模式，开发者可根据场景选择合适的方式。

4.3.1 CompletionHandler 回调模式

回调模式通过实现CompletionHandler接口的completed()和failed()方法处理操作结果，当异步操作完成或失败时，对应的方法会被自动调用。

java

package com.io.aio;import lombok.extern.slf4j.Slf4j;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;/*** AIO服务器（基于CompletionHandler回调模式）*/
@Slf4j
public class AioServer {private static final int PORT = 8080;private static final int BUFFER_SIZE = 1024;public static void main(String[] args) {try {// 创建异步服务器通道AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();// 绑定端口serverChannel.bind(new InetSocketAddress(PORT));log.info("AIO服务器启动成功，监听端口：{}", PORT);// 异步接受连接，指定CompletionHandlerserverChannel.accept(null, new AcceptCompletionHandler(serverChannel));// 保持服务器运行（防止主线程退出）Thread.currentThread().join();} catch (IOException e) {log.error("AIO服务器启动异常", e);} catch (InterruptedException e) {log.error("服务器主线程被中断", e);Thread.currentThread().interrupt();}}/*** 连接接受完成处理器*/private static class AcceptCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, Void> {private final AsynchronousServerSocketChannel serverChannel;public AcceptCompletionHandler(AsynchronousServerSocketChannel serverChannel) {this.serverChannel = serverChannel;}/*** 连接接受成功时回调*/@Overridepublic void completed(AsynchronousSocketChannel clientChannel, Void attachment) {log.info("新客户端连接：{}:{}",clientChannel.getRemoteAddress().toString().split(":")[0],clientChannel.getRemoteAddress().toString().split(":")[1]);// 继续接受其他连接serverChannel.accept(null, this);// 准备读取客户端数据ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);// 异步读取数据，指定CompletionHandlerclientChannel.read(buffer, buffer, new ReadCompletionHandler(clientChannel));}/*** 连接接受失败时回调*/@Overridepublic void failed(Throwable exc, Void attachment) {log.error("接受客户端连接失败", exc);// 继续接受其他连接serverChannel.accept(null, this);}}/*** 读操作完成处理器*/private static class ReadCompletionHandler implements CompletionHandler<Integer, ByteBuffer> {private final AsynchronousSocketChannel clientChannel;public ReadCompletionHandler(AsynchronousSocketChannel clientChannel) {this.clientChannel = clientChannel;}/*** 读操作成功完成时回调*/@Overridepublic void completed(Integer bytesRead, ByteBuffer buffer) {if (bytesRead > 0) {// 切换到读模式buffer.flip();// 读取数据byte[] bytes = new byte[buffer.remaining()];buffer.get(bytes);String message = new String(bytes, StandardCharsets.UTF_8);log.info("收到客户端消息：{}", message);// 准备响应数据String response = "服务器已收到：" + message;ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes(StandardCharsets.UTF_8));// 异步写入响应，指定CompletionHandlerclientChannel.write(responseBuffer, responseBuffer, new WriteCompletionHandler(clientChannel));} else if (bytesRead < 0) {// 客户端关闭连接try {log.info("客户端断开连接：{}", clientChannel.getRemoteAddress());clientChannel.close();} catch (Exception e) {log.error("关闭客户端连接异常", e);}}}/*** 读操作失败时回调*/@Overridepublic void failed(Throwable exc, ByteBuffer buffer) {log.error("读取客户端数据失败", exc);try {clientChannel.close();} catch (IOException e) {log.error("关闭客户端连接异常", e);}}}/*** 写操作完成处理器*/private static class WriteCompletionHandler implements CompletionHandler<Integer, ByteBuffer> {private final AsynchronousSocketChannel clientChannel;public WriteCompletionHandler(AsynchronousSocketChannel clientChannel) {this.clientChannel = clientChannel;}/*** 写操作成功完成时回调*/@Overridepublic void completed(Integer bytesWritten, ByteBuffer buffer) {// 检查是否还有未写完的数据if (buffer.hasRemaining()) {// 继续写入剩余数据clientChannel.write(buffer, buffer, this);} else {log.info("响应已发送，准备继续读取客户端数据");// 准备继续读取客户端数据ByteBuffer newBuffer = ByteBuffer.allocate(BUFFER_SIZE);clientChannel.read(newBuffer, newBuffer, new ReadCompletionHandler(clientChannel));}}/*** 写操作失败时回调*/@Overridepublic void failed(Throwable exc, ByteBuffer buffer) {log.error("向客户端写入数据失败", exc);try {clientChannel.close();} catch (IOException e) {log.error("关闭客户端连接异常", e);}}}
}
4.3.2 Future 模式

Future 模式通过Future对象获取异步操作结果，用户线程可以通过get()方法阻塞等待结果，或通过isDone()方法轮询检查是否完成。

java

package com.io.aio;import lombok.extern.slf4j.Slf4j;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;/*** AIO客户端（基于Future模式）*/
@Slf4j
public class AioClient {private static final String SERVER_HOST = "localhost";private static final int SERVER_PORT = 8080;private static final int BUFFER_SIZE = 1024;public static void main(String[] args) {try {// 创建异步客户端通道AsynchronousSocketChannel clientChannel = AsynchronousSocketChannel.open();// 异步连接服务器，获取Future对象Future<Void> connectFuture = clientChannel.connect(new InetSocketAddress(SERVER_HOST, SERVER_PORT));// 等待连接完成（Future.get()会阻塞直到操作完成）connectFuture.get();log.info("已成功连接到服务器：{}:{}", SERVER_HOST, SERVER_PORT);// 启动用户输入线程startInputThread(clientChannel);// 循环读取服务器响应ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);while (true) {// 异步读取数据，获取Future对象Future<Integer> readFuture = clientChannel.read(buffer);// 等待读取完成int bytesRead = readFuture.get();if (bytesRead > 0) {buffer.flip();byte[] bytes = new byte[buffer.remaining()];buffer.get(bytes);log.info("收到服务器响应：{}", new String(bytes, StandardCharsets.UTF_8));buffer.clear();} else if (bytesRead < 0) {// 服务器关闭连接log.info("服务器已断开连接");clientChannel.close();System.exit(0);}}} catch (ExecutionException e) {log.error("AIO操作执行异常", e.getCause());} catch (Exception e) {log.error("AIO客户端异常", e);}}/*** 启动用户输入线程*/private static void startInputThread(AsynchronousSocketChannel clientChannel) {Thread inputThread = new Thread(() -> {Scanner scanner = new Scanner(System.in);try {while (true) {System.out.print("请输入消息（输入exit退出）：");String message = scanner.nextLine();if ("exit".equalsIgnoreCase(message)) {log.info("客户端准备退出");clientChannel.close();System.exit(0);}// 异步发送消息ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));Future<Integer> writeFuture = clientChannel.write(buffer);// 等待发送完成int bytesWritten = writeFuture.get();log.info("消息已发送，字节数：{}", bytesWritten);}} catch (ExecutionException e) {log.error("发送消息执行异常", e.getCause());} catch (Exception e) {log.error("输入线程异常", e);} finally {scanner.close();}}, "Input-Thread");inputThread.setDaemon(true);inputThread.start();}
}

4.4 AIO 与 NIO 的本质区别

AIO 和 NIO 虽然都支持非阻塞，但它们在处理 IO 操作的方式上有本质区别，主要体现在以下几个方面：

特性NIOAIO
模型类型同步非阻塞异步非阻塞
阻塞阶段数据复制阶段阻塞无阻塞阶段
线程角色线程需主动轮询事件并处理 IO线程仅发起 IO 和处理结果
操作系统支持依赖 Selector 多路复用依赖操作系统异步 IO 支持
适用场景高并发短连接IO 密集型长耗时操作
编程复杂度中等（需管理 Selector 和事件）较高（需处理回调和状态）

核心区别解析：

  • 同步 vs 异步：NIO 是同步的，因为数据复制阶段需要用户线程参与；AIO 是异步的，整个 IO 过程由操作系统完成
  • 主动性 vs 被动性：NIO 需要用户线程主动调用select()轮询事件；AIO 由操作系统主动通知完成事件
  • 资源占用：NIO 在高并发下仍需一定数量的线程处理事件；AIO 可在极少线程下支持大量并发 IO

4.5 AIO 的适用场景与局限性

AIO 作为最先进的 IO 模型，在特定场景下能发挥最大价值，但也存在一定的局限性。

AIO 适用场景：

  • IO 密集型应用（如文件服务器、备份系统）
  • 高延迟 IO 操作（如跨网络的数据库查询）
  • 连接数极多且每个连接 IO 操作耗时较长的场景
  • 需要最大化 CPU 利用率的场景

AIO 的局限性：

  1. 操作系统支持差异：Windows 系统通过 IOCP 良好支持 AIO，而 Linux 系统在 2.6 版本后才通过 epoll 支持，实现效率不如 Windows
  2. JDK 实现问题：Java AIO 在 Linux 下实际是基于 NIO 模拟实现的，并非真正的操作系统级异步 IO
  3. 编程复杂度高：异步回调模式容易导致代码逻辑分散，调试和维护难度大
  4. 短连接场景优势不明显：对于短连接高频 IO 场景，AIO 的回调开销可能超过其性能优势

4.6 AIO 的最佳实践

尽管 AIO 存在一定局限性，但在合适的场景下仍能显著提升性能，以下是 AIO 开发的最佳实践：

  1. 合理选择编程模式：

    • 简单场景使用 Future 模式，代码更直观
    • 复杂场景使用 CompletionHandler 模式，分离关注点
    • 考虑使用 CompletableFuture 封装 AIO 操作，简化编程

  2. 回调管理策略：

    • 使用线程池处理回调任务，避免回调线程过载
    • 回调函数中只处理结果分发，避免执行耗时操作
    • 实现回调链管理，处理复杂的异步操作序列

  3. 资源管理：

    • 确保通道和缓冲区正确关闭，避免资源泄漏
    • 实现连接超时机制，清理长时间未完成的操作
    • 对回调对象进行生命周期管理，避免内存泄漏

  4. 错误处理：

    • 完善的异常处理机制，避免单个 IO 错误导致整个应用崩溃
    • 实现重试机制，处理临时 IO 失败
    • 记录详细的 IO 操作日志，便于问题排查

五、BIO、NIO、AIO 全方位对比与技术选型

5.1 三种 IO 模型核心特性对比

为了更清晰地理解 BIO、NIO、AIO 的差异，我们从多个维度进行全方位对比：

对比维度BIONIOAIO
模型类型同步阻塞同步非阻塞异步非阻塞
核心组件ServerSocket/Socket、StreamBuffer、Channel、SelectorAsynchronousChannel、CompletionHandler、Future
线程与连接关系1 线程：1 连接1 线程：N 连接M 线程：N 连接 (M<<N)
阻塞阶段accept ()、read ()、write () 均阻塞select () 阻塞，read ()/write () 非阻塞无阻塞阶段
并发能力低（依赖线程数）高（单线程管理多连接）极高（完全异步）
编程复杂度简单中等高
系统资源消耗高（线程多）中（线程少）低（线程极少）
适用连接数少（数百级）中（数万级）多（数十万级）
数据处理时机实时处理就绪时处理完成后处理
典型应用简单 TCP 服务Netty、Tomcat8+高性能文件服务器

5.2 性能表现对比

在不同并发规模下，三种 IO 模型的性能表现差异显著：

  • 低并发场景（<1000 连接）：

    • BIO：性能足够，编程简单，资源消耗可接受
    • NIO：性能略优，但编程复杂度高，优势不明显
    • AIO：性能优势不明显，回调开销可能抵消收益

  • 中高并发场景（1000-10000 连接）：

    • BIO：线程资源耗尽，性能急剧下降
    • NIO：性能稳定，资源消耗可控，优势明显
    • AIO：性能接近 NIO，在 Windows 环境下可能略优

  • 超高并发场景（>10000 连接）：

    • BIO：完全不可用
    • NIO：通过多 Selector 优化可支持，但需精细调优
    • AIO：理论性能最优，尤其在 IO 密集型场景

5.3 技术选型决策指南

选择合适的 IO 模型需要综合考虑业务场景、技术成熟度、团队能力等多方面因素，以下是具体的决策指南：

优先选择 BIO 的场景：

  • 连接数固定且较少（如内部管理系统）
  • 开发周期短，维护成本优先
  • 团队对 NIO/AIO 技术不熟悉
  • 单个 IO 操作耗时较长且并发低

优先选择 NIO 的场景：

  • 高并发网络应用（如 Web 服务器、游戏服务器）
  • 大量短连接场景（如 HTTP 服务）
  • 需要跨平台部署（Linux 环境 NIO 更成熟）
  • 追求性能与开发复杂度的平衡

优先选择 AIO 的场景：

  • Windows 平台下的高并发 IO 应用
  • IO 密集型应用（如大文件传输）
  • 对 CPU 利用率有极致要求
  • 长耗时 IO 操作场景（如远程服务调用）

实际开发建议：

  1. 大多数业务场景下，优先使用成熟框架（如 Netty）而非直接使用原生 NIO/AIO
  2. 新系统设计时，建议基于 NIO 模型构建核心框架，预留扩展空间
  3. 性能敏感场景需进行充分压测，验证不同 IO 模型的实际表现
  4. 考虑混合 IO 模型：核心高频路径使用 NIO，低频长耗时操作使用 AIO

六、IO 模型在实际框架中的应用

理论上的 IO 模型差异在实际应用中会被框架进一步封装和优化，了解主流框架对 IO 模型的选择和改造，能帮助我们更好地理解 IO 模型的实际价值。

6.1 Netty：基于 NIO 的高性能通信框架

Netty 是 Java 领域最流行的高性能网络通信框架，它基于 NIO 模型进行了深度优化，解决了原生 NIO 的诸多痛点：

Netty 对 NIO 的改进：

  • 解决了 NIO 的空轮询 Bug（JDK NIO 的 Selector.select () 可能无限返回 0）
  • 提供了更易用的 API，简化了 NIO 的复杂编程模型
  • 内置了多种编解码器，处理 TCP 粘包 / 拆包问题
  • 实现了高效的线程模型（主从 Reactor 模型）
  • 提供了丰富的事件处理器和通道处理器

Netty 的线程模型：
Netty 采用主从 Reactor 模型，是 NIO 多路复用的最佳实践：

  • BossGroup（主 Reactor）：负责监听客户端连接，将连接分配给 WorkerGroup
  • WorkerGroup（从 Reactor）：负责处理已建立的连接的 IO 操作
  • 每个 Reactor 对应一个 Selector，实现高效的事件多路复用

Netty 示例：简单的 Echo 服务器

java

运行

package com.io.framework;import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import lombok.extern.slf4j.Slf4j;/*** Netty Echo服务器示例* 基于NIO模型，展示高性能网络通信框架的使用*/
@Slf4j
public class NettyEchoServer {private static final int PORT = 8080;public static void main(String[] args) throws InterruptedException {// 1. 创建BossGroup和WorkerGroup// BossGroup：处理连接请求，通常设置为1个线程EventLoopGroup bossGroup = new NioEventLoopGroup(1);// WorkerGroup：处理IO操作，线程数默认是CPU核心数*2EventLoopGroup workerGroup = new NioEventLoopGroup();try {// 2. 创建服务器启动助手ServerBootstrap bootstrap = new ServerBootstrap();// 3. 配置启动参数bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) // 使用NIO服务器通道.option(ChannelOption.SO_BACKLOG, 128) // 连接队列大小.childOption(ChannelOption.SO_KEEPALIVE, true) // 保持连接.childHandler(new ChannelInitializer<SocketChannel>() {// 4. 设置通道处理器@Overrideprotected void initChannel(SocketChannel ch) throws Exception {// 获取管道ChannelPipeline pipeline = ch.pipeline();// 添加字符串编解码器pipeline.addLast(new StringDecoder());pipeline.addLast(new StringEncoder());// 添加自定义处理器pipeline.addLast(new EchoServerHandler());}});log.info("Netty Echo服务器启动，监听端口：{}", PORT);// 5. 绑定端口，同步等待成功ChannelFuture future = bootstrap.bind(PORT).sync();// 6. 等待服务器关闭future.channel().closeFuture().sync();} finally {// 7. 优雅关闭线程组bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();log.info("Netty服务器已关闭");}}/*** 自定义Echo处理器*/@ChannelHandler.Sharableprivate static class EchoServerHandler extends SimpleChannelInboundHandler<String> {@Overridepublic void channelActive(ChannelHandlerContext ctx) throws Exception {log.info("客户端连接：{}", ctx.channel().remoteAddress());}@Overrideprotected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {log.info("收到客户端[{}]消息：{}", ctx.channel().remoteAddress(), msg);// 发送响应（Echo）ctx.writeAndFlush("服务器已收到：" + msg);}@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {log.error("发生异常", cause);ctx.close();}@Overridepublic void channelInactive(ChannelHandlerContext ctx) throws Exception {log.info("客户端断开连接：{}", ctx.channel().remoteAddress());}}
}

Netty 通过封装 NIO 的复杂性，提供了简洁易用的 API，同时保持了 NIO 的高性能特性，成为构建高性能中间件（如 Dubbo、Elasticsearch）的首选框架。

6.2 Tomcat：IO 模型的演进与选择

Tomcat 作为最流行的 Java Web 服务器，其 IO 模型经历了从 BIO 到 NIO 再到 APR（Apache Portable Runtime）的演进：

Tomcat 的 IO 模型选择：

  • BIO：Tomcat 7 及之前的默认 IO 模型，适用于低并发场景
  • NIO：Tomcat 8 及之后的默认 IO 模型，基于 Java NIO 实现，支持高并发
  • NIO.2：基于 Java AIO 的实现，在 Windows 环境下表现较好
  • APR：通过 JNI 调用操作系统原生 IO 接口，性能最优但配置复杂

Tomcat IO 模型配置：
在 server.xml 中通过 protocol 属性指定 IO 模型：

xml

<!-- BIO模型 -->
<Connector port="8080" protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8443" /><!-- NIO模型 -->
<Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"connectionTimeout="20000"redirectPort="8443" /><!-- NIO.2(AIO)模型 -->
<Connector port="8080" protocol="org.apache.coyote.http11.Http11Nio2Protocol"connectionTimeout="20000"redirectPort="8443" /><!-- APR模型 -->
<Connector port="8080" protocol="org.apache.coyote.http11.Http11AprProtocol"connectionTimeout="20000"redirectPort="8443" />

Tomcat 的 IO 模型演进体现了不同 IO 模型在 Web 服务器领域的应用实践，也反映了随着并发需求增长对高性能 IO 模型的迫切需求。

6.3 Java NIO.2：AIO 的标准化实现

JDK 7 引入的 NIO.2（也称为 AIO）是 Java 对异步 IO 的标准化支持，它在java.nio.file包中提供了丰富的异步文件操作 API：

java

运行

package com.io.framework;import lombok.extern.slf4j.Slf4j;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;/*** NIO.2异步文件操作示例* 展示AIO在文件操作中的应用*/
@Slf4j
public class Nio2FileOperations {private static final String FILE_PATH = "nio2_demo.txt";public static void main(String[] args) {try {// 1. 异步写入文件（基于CompletionHandler）writeFileWithCompletionHandler();// 2. 异步读取文件（基于Future）readFileWithFuture();// 等待异步操作完成Thread.sleep(1000);} catch (Exception e) {log.error("NIO.2文件操作异常", e);}}/*** 使用CompletionHandler异步写入文件*/private static void writeFileWithCompletionHandler() throws Exception {Path path = Paths.get(FILE_PATH);// 创建异步文件通道（支持写入和创建）AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path,EnumSet.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING));String content = "Hello NIO.2 Asynchronous File Operations!";ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());// 异步写入文件fileChannel.write(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {@Overridepublic void completed(Integer bytesWritten, ByteBuffer attachment) {log.info("异步写入完成，写入字节数：{}", bytesWritten);try {fileChannel.close();} catch (Exception e) {log.error("关闭文件通道异常", e);}}@Overridepublic void failed(Throwable exc, ByteBuffer attachment) {log.error("异步写入失败", exc);try {fileChannel.close();} catch (Exception e) {log.error("关闭文件通道异常", e);}}});}/*** 使用Future异步读取文件*/private static void readFileWithFuture() throws Exception {Path path = Paths.get(FILE_PATH);// 创建异步文件通道（支持读取）AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path,StandardOpenOption.READ);ByteBuffer buffer = ByteBuffer.allocate(1024);// 异步读取文件，获取FutureFuture<Integer> future = fileChannel.read(buffer, 0);// 处理读取结果new Thread(() -> {try {// 等待读取完成int bytesRead = future.get();log.info("异步读取完成，读取字节数：{}", bytesRead);// 处理数据buffer.flip();byte[] bytes = new byte[buffer.remaining()];buffer.get(bytes);log.info("文件内容：{}", new String(bytes));fileChannel.close();} catch (InterruptedException e) {log.error("读取线程被中断", e);Thread.currentThread().interrupt();} catch (ExecutionException e) {log.error("读取操作执行异常", e.getCause());} catch (Exception e) {log.error("读取文件异常", e);}}).start();}
}

NIO.2 提供的异步文件操作 API 使 Java 能够更高效地处理文件 IO，特别适合需要处理大量文件或大文件的场景。

七、IO 模型性能优化实战

选择合适的 IO 模型只是高性能 IO 应用的基础，要充分发挥 IO 模型的性能潜力，还需要进行针对性的优化。

7.1 网络 IO 性能优化策略

网络 IO 性能受多种因素影响，以下是经过实践验证的优化策略：

1. 缓冲区优化：

  • 合理设置缓冲区大小：网络 IO 通常设置为 8KB~64KB，文件 IO 可更大
  • 重用缓冲区：避免频繁创建和销毁缓冲区，减少 GC 压力
  • 优先使用直接缓冲区：对于长期存在的缓冲区，直接缓冲区性能更优

2. 连接管理：

  • 使用长连接代替短连接：减少 TCP 握手和挥手开销
  • 实现连接池：复用连接，避免频繁创建连接
  • 设置合理的超时时间：包括连接超时、读写超时，避免资源浪费

3. 数据传输优化：

  • 批量读写：减少 IO 操作次数
  • 压缩传输：减少数据传输量（如使用 gzip 压缩）
  • 协议优化：使用二进制协议代替文本协议（如 Protobuf 代替 JSON）

4. 线程模型优化：

  • 根据 CPU 核心数设置合理的线程数：通常为 CPU 核心数的 1~2 倍
  • 分离 IO 线程和业务线程：避免业务处理阻塞 IO 线程
  • 使用线程局部变量：减少线程间竞争

5. 操作系统优化：

  • 调整 TCP 参数：如增大 TCP 缓冲区、调整超时时间
  • 增加文件描述符限制：允许更多并发连接
  • 启用 Nagle 算法：减少小包传输（延迟敏感场景可关闭）

7.2 压测对比：BIO vs NIO vs AIO

为了直观展示三种 IO 模型的性能差异，我们设计了一个简单的压测场景：在相同硬件环境下，分别测试三种模型在不同并发连接数下的吞吐量和响应时间。

压测环境：

  • CPU：Intel Core i7-10700K（8 核 16 线程）
  • 内存：32GB DDR4
  • 操作系统：Windows 10
  • JDK 版本：OpenJDK 17

压测结果：

并发连接数模型吞吐量（请求 / 秒）平均响应时间（ms）95% 响应时间（ms）
100BIO850118156
100NIO32003145
100AIO34002942
500BIO920543890
500NIO580086120
500AIO620081115
1000BIO78012822150
1000NIO7500133185
1000AIO8100123170
5000BIO失败（OOM）--
5000NIO12500400520
5000AIO14200352470
10000BIO失败（OOM）--
10000NIO15800633780
10000AIO18500540680

压测结论：

  1. 低并发场景下，三种模型性能差异不大，但 BIO 实现最简单
  2. 中高并发场景下，NIO 和 AIO 性能远超 BIO，且 AIO 略优于 NIO
  3. 超高并发场景下，BIO 完全不可用，NIO 和 AIO 仍能保持较高性能
  4. AIO 在 Windows 环境下表现优于 NIO，尤其在高并发场景

7.3 常见性能问题诊断与解决

IO 性能问题往往具有隐蔽性，需要通过专业工具和方法进行诊断：

1. 连接数瓶颈：

  • 症状：新连接无法建立，报 "too many open files" 错误
  • 诊断：使用netstat命令查看连接状态，检查文件描述符限制
  • 解决：增加操作系统文件描述符限制，优化连接超时设置

2. 线程阻塞：

  • 症状：CPU 利用率低但响应慢，线程状态多为 BLOCKED 或 WAITING
  • 诊断：使用jstack命令分析线程堆栈，识别阻塞点
  • 解决：减少锁竞争，避免在 IO 线程中执行耗时操作

3. 缓冲区问题：

  • 症状：IO 操作频繁，内存占用高，GC 频繁
  • 诊断：使用jmap和jconsole分析内存使用情况
  • 解决：重用缓冲区，调整缓冲区大小，合理使用直接缓冲区

4. 网络瓶颈：

  • 症状：吞吐量上不去，网络带宽利用率低
  • 诊断：使用iftop等工具监控网络流量，分析 TCP 参数
  • 解决：调整 TCP 缓冲区，启用数据压缩，优化协议设计

八、总结与展望

IO 模型是 Java 并发编程的基础，从 BIO 到 NIO 再到 AIO，每一次演进都带来了性能的飞跃和编程模型的变革。

8.1 三种 IO 模型的核心价值

  • BIO：简单直观，适合低并发场景，是理解 IO 模型的基础
  • NIO：平衡了性能和复杂度，是高并发网络编程的首选
  • AIO：代表未来趋势，全异步特性适合 IO 密集型场景

8.2 技术选择的基本原则

  • 没有银弹：不存在适用于所有场景的 IO 模型，需根据实际需求选择
  • 权衡利弊：性能、复杂度、可维护性、团队熟悉度需综合考虑
  • 渐进优化：从简单模型开始，根据性能瓶颈逐步升级
  • 善用框架：优先使用成熟框架（如 Netty）而非原生 API

8.3 IO 模型的未来发展

随着硬件和操作系统的发展，IO 模型也在不断演进：

  • 用户态 IO：绕过内核直接访问硬件，进一步提升性能
  • 异步 IO 普及：随着 Linux 对异步 IO 的支持完善，AIO 将获得更广泛应用
  • 智能 IO 调度：结合 AI 技术预测 IO 需求，动态调整 IO 策略
  • 融合模型：混合使用多种 IO 模型，根据场景自动切换

IO 模型的选择和优化是一个持续的过程，需要开发者不断学习和实践。理解 BIO、NIO、AIO 的本质差异和适用场景，将帮助我们构建更高效、更稳定的 Java 应用。

http://www.dtcms.com/a/332807.html

相关文章：

  • Cherryusb UAC例程对接STM32 SAI播放音乐和录音(下)=＞USB+SAI+TX+RX+DMA控制WM8978播放和录音实验
  • 【嵌入式FreeRTOS#补充1】临界区
  • K-means 聚类算法学习笔记
  • 解锁PostgreSQL专家认证增强驱动引擎
  • 打靶日常-sql注入(手工+sqlmap)
  • 136-基于Spark的酒店数据分析系统
  • Python Sqlalchemy数据库连接
  • 紫金桥RealSCADA：国产工业大脑，智造安全基石
  • 【已解决】在Spring Boot工程中，若未识别到resources/db文件夹下的SQL文件
  • JavaScript 防抖（Debounce）与节流（Throttle）
  • 易道博识康铁钢：大小模型深度融合是现阶段OCR的最佳解决方案
  • 【Trans2025】计算机视觉|UMFormer：即插即用！让遥感图像分割更精准！
  • Notepad++插件开发实战指南
  • Radar Forward-Looking Imaging Based on Chirp Beam Scanning论文阅读
  • 《WINDOWS 环境下32位汇编语言程序设计》第1章 背景知识
  • 【Linux】探索Linux虚拟地址空间及其管理机制
  • C# HangFire的使用
  • 概率论基础教程第2章概率论公理(习题和解答)
  • 在 Linux 服务器搭建Coturn即ICE/TURN/STUN实现P2P（点对点）直连
  • HarmonyOS 实战：用 @Observed + @ObjectLink 玩转多组件实时数据更新
  • pyecharts可视化图表-pie：从入门到精通（进阶篇）
  • Python 数据可视化：柱状图/热力图绘制实例解析
  • 概率论基础教程第2章概率论公理
  • 享元模式C++
  • 基于深度学习的零件缺陷识别方法研究（LW+源码+讲解+部署）
  • 力扣hot100 | 普通数组 | 53. 最大子数组和、56. 合并区间、189. 轮转数组、238. 除自身以外数组的乘积、41. 缺失的第一个正数
  • 什么才是真正的白盒测试？
  • 专题三_二分_x 的平方根
  • JavaScript 解析 Modbus 响应数据的实现方法
  • 记录处理：Caused by: java.lang.UnsatisfiedLinkError