Java NIO 详解（Channel+Buffer+Selector）

一、介绍

Java NIO（Non-blocking IO，非阻塞 IO）是 JDK 1.4 引入的新一代 IO 框架（位于 java.nio 及子包），核心目标是解决传统 IO（BIO）在高并发、大文件场景下的性能瓶颈。与传统 IO 的 "流模型" 不同，NIO 采用「通道 - 缓冲区（Channel-Buffer）」模型，支持非阻塞 IO 和多路复用，是高性能网络编程（如 Netty、Tomcat）、大文件处理的核心基础。

Java NIO 的核心设计是 "面向缓冲区（Buffer）+ 通道（Channel）+ 选择器（Selector）"，辅以文件 / 网络相关的工具类.

特性：

特性	说明
非阻塞 IO（Non-blocking）	线程发起 IO 操作后无需阻塞等待结果，可继续处理其他任务，结果就绪后再回调
通道 - 缓冲区模型	数据必须通过缓冲区（Buffer）读写，通道（Channel）是双向的（传统流是单向）
多路复用（Selector）	单个线程可监听多个通道的 IO 事件（如连接、读就绪、写就绪），提升并发效率
零拷贝（Zero-Copy）	支持直接缓冲区和 `FileChannel.transferTo()`，减少内核态 / 用户态内存拷贝
编码标准化	内置 `Charset` 类统一处理字符编码，替代传统 IO 转换流的底层实现

二、NIO 核心组件

1. 缓冲区（Buffer）：数据容器

Buffer 是 NIO 中存储数据的核心容器（类似数组，但提供更精细的读写控制），所有 NIO 数据操作都必须通过 Buffer 完成。

（1）类型

类型	适用数据	备注
`ByteBuffer`	字节（最常用）	可分为「直接缓冲区」「堆缓冲区」
`CharBuffer`	字符	处理文本数据
`IntBuffer`/`LongBuffer`	基本数据类型	读写 int/long 等数值

（2）属性（Buffer 读写的关键）

属性	含义
`capacity`	缓冲区总容量（创建后不可变）
`position`	当前读写位置（初始为 0，读写后自动后移）
`limit`	读写的边界（写模式下 = capacity，读模式下 = 写时的 position）
`mark`	标记位（可通过 `mark()` 标记位置，`reset()` 恢复到标记位）

（3）操作

java 复制代码

// 1. 创建 ByteBuffer（堆缓冲区，容量 1024）
ByteBuffer buf = ByteBuffer.allocate(1024); 
// 2. 直接缓冲区（内存分配在操作系统内核，减少拷贝，适合大文件）
ByteBuffer directBuf = ByteBuffer.allocateDirect(1024);

// 写数据到缓冲区
buf.put("Hello NIO".getBytes()); 

// 切换为读模式（关键：limit=position，position=0）
buf.flip(); 

// 读数据
byte[] bytes = new byte[buf.remaining()]; // remaining() = limit - position
buf.get(bytes); 
System.out.println(new String(bytes));

// 清空缓冲区（position=0，limit=capacity，数据未真正删除）
buf.clear(); 
// 压缩缓冲区（保留未读数据，position=未读起始位置，limit=capacity）
buf.compact();

2. 通道（Channel）：数据传输通道

Channel 是 NIO 中连接「数据源 / 目的地」的双向通道（可同时读写，传统流是单向），所有数据必须通过 Channel 读取到 Buffer，或从 Buffer 写入到 Channel。

（1）类型

通道类型	适用场景	关键特性
`FileChannel`	文件读写	支持阻塞 / 非阻塞、零拷贝、随机访问
`SocketChannel`	TCP 客户端通信	支持非阻塞连接、读写
`ServerSocketChannel`	TCP 服务端监听	非阻塞接受连接
`DatagramChannel`	UDP 通信	非阻塞读写数据报

（2）操作（以 FileChannel 为例）

java 复制代码

try (FileChannel inChannel = new FileInputStream("source.txt").getChannel();
     FileChannel outChannel = new FileOutputStream("target.txt").getChannel()) {

    ByteBuffer buf = ByteBuffer.allocate(1024);
    // 1. 从通道读取数据到缓冲区
    while (inChannel.read(buf) != -1) {
        buf.flip(); // 切换读模式
        // 2. 从缓冲区写入数据到通道
        outChannel.write(buf);
        buf.clear(); // 清空缓冲区，准备下次写入
    }

    // 零拷贝优化（大文件传输，无需手动缓冲区）
    inChannel.transferTo(0, inChannel.size(), outChannel);
} catch (IOException e) {
    e.printStackTrace();
}

3. 选择器（Selector）：多路复用核心

Selector 是 NIO 实现「单线程处理多通道」的核心组件，也叫 "多路复用器"。线程通过 Selector 监听多个 Channel 的 IO 事件（如连接就绪、读就绪、写就绪），仅在事件发生时才处理，避免线程阻塞等待。

（1）核心事件类型

事件常量	含义
`SelectionKey.OP_READ`	通道可读
`SelectionKey.OP_WRITE`	通道可写
`SelectionKey.OP_CONNECT`	客户端连接完成
`SelectionKey.OP_ACCEPT`	服务端接受连接就绪

（2）Selector 核心流程（服务端示例）

java 复制代码

// 1. 创建 Selector
Selector selector = Selector.open();

// 2. 创建 ServerSocketChannel 并配置非阻塞
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);

// 3. 注册通道到 Selector，监听 ACCEPT 事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

// 4. 循环监听事件
while (true) {
    // 阻塞等待事件（可指定超时时间）
    int readyChannels = selector.select(); 
    if (readyChannels == 0) continue;

    // 5. 处理就绪的事件
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> iterator = selectedKeys.iterator();
    while (iterator.hasNext()) {
        SelectionKey key = iterator.next();
        // 处理接受连接事件
        if (key.isAcceptable()) {
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            SocketChannel sc = ssc.accept();
            sc.configureBlocking(false);
            // 注册新连接到 Selector，监听 READ 事件
            sc.register(selector, SelectionKey.OP_READ);
        }
        // 处理读事件
        else if (key.isReadable()) {
            SocketChannel sc = (SocketChannel) key.channel();
            ByteBuffer buf = ByteBuffer.allocate(1024);
            int len = sc.read(buf);
            if (len > 0) {
                buf.flip();
                System.out.println("收到数据：" + new String(buf.array(), 0, len));
            } else if (len == -1) {
                sc.close(); // 客户端断开连接
            }
        }
        // 移除已处理的 key（避免重复处理）
        iterator.remove();
    }
}

打个比方：

把 Java NIO 的工作过程比作 "快递仓库的货物收发系统"：

组件	角色	作用对应	场景解释
Buffer（缓冲区）	标准化快递箱	存储数据的容器	所有货物（数据）必须装进统一规格的快递箱（Buffer）才能运输，箱子有固定容量（capacity）、当前装货位置（position）、最大装货边界（limit）。比如：装完货后要封箱（`flip()`）才能扫码出库（读数据）；没装满的箱子可以把剩余空间往前挪（`compact()`）继续装货。
Channel（通道）	仓库的运输管道	连接数据源与 Buffer 的双向通道	管道一头连仓库外的货车（文件 / 网络等数据源），一头连仓库内部（Buffer），支持双向运输（既可以进货也可以出货）。比如：`FileChannel` 是连接本地仓库和货车的管道，`SocketChannel` 是连接远程仓库和货车的管道；管道可以设置 "非阻塞模式"------ 没货的时候不用等，有货了再通知。
Selector（选择器）	仓库调度中心	单线程管理多个 Channel 的事件	调度中心（Selector）同时监控多条运输管道（Channel），不用给每条管道配一个工人（线程）。当某条管道有货物到达（`OP_READ`）、可以发货（`OP_WRITE`）、有新货车接入（`OP_ACCEPT`）时，调度中心会收到通知，然后安排一个工人去处理这条管道的任务，实现 "一人管多线" 的高效调度。

辅助组件：

Charset（字符集） → 货物打包 / 拆包的翻译员负责把 "字符货物" 和 "字节货物" 互相转换，比如把中文（字符）打包成 UTF-8 格式的字节（适合运输），或者把收到的字节拆包还原成中文。
FileLock（文件锁） → 仓库货物的防盗锁当一条管道在搬运某批货物（文件）时，给货物上锁，防止其他管道同时搬运导致货物混乱，保证数据的安全性。
Pipe（管道） → 仓库内部的传送带 专门用于仓库内部不同区域（线程）之间的货物传递，一头是发货口（SinkChannel），一头是收货口（SourceChannel）。

三、流程：

NIO 基础读写流程（FileChannel 阻塞模式）

是
否
开始
打开FileChannel通道

FileChannel.open(Path, 读写模式)
分配Buffer缓冲区

allocate/allocateDirect
Channel读取数据到Buffer

channel.read(buffer)
Buffer切换为读模式

buffer.flip()
从Buffer读取数据（业务处理）
是否需要写入数据？
Buffer写入数据到Channel

channel.write(buffer)
清空/压缩Buffer

clear()/compact()
关闭Channel

channel.close()
结束

NIO 多路复用核心流程（Selector + Socket 服务端）

是
否
OP_ACCEPT
OP_READ
是
否
是
否
开始
初始化ServerSocketChannel

open()
bind(端口)
configureBlocking(false)
创建Selector

Selector.open()
注册ServerSocketChannel到Selector

selector.select()
是否有就绪通道？
获取就绪SelectionKey集合

selector.selectedKeys()
遍历SelectionKey迭代器
事件类型？
接受客户端连接

serverChannel.accept()
配置SocketChannel非阻塞

configureBlocking(false)
注册SocketChannel到Selector

iterator.remove()
获取客户端SocketChannel

key.channel()
Buffer读取通道数据

channel.read(buffer)
Buffer flip()切换读模式
业务处理读取的数据
连接是否关闭？
关闭Channel+取消Key

channel.close()/key.cancel()
清空Buffer

buffer.clear()
是否继续轮询？
结束

四、NIO vs 传统 IO（BIO）

维度	传统 IO（BIO）	NIO
模型	流模型（单向）	通道 - 缓冲区模型（双向）
阻塞方式	阻塞式（线程等待 IO 完成）	支持非阻塞式
并发处理	一个连接一个线程（高并发下线程爆炸）	单线程处理多连接（Selector 多路复用）
数据操作	直接读写流，无缓冲区控制	必须通过 Buffer 读写
性能	低（频繁系统调用、线程切换）	高（零拷贝、减少系统调用）
编程复杂度	简单	复杂（需处理事件、缓冲区状态）
适用场景	低并发、简单文件读写	高并发网络编程、大文件处理

五、NIO.2（JDK 7+）：NIO 的增强版

JDK 7 推出 NIO.2（java.nio.file 包），核心是重构文件 IO 操作，解决传统 File 类的缺陷：

1. 核心 API

API	作用
`Path`	替代 `File` 类，更优雅的文件路径表示（支持跨平台）
`Paths`	工具类，创建 `Path` 对象（如 `Paths.get("test.txt")`）
`Files`	工具类，提供一站式文件操作（读写、复制、遍历、监听）
`WatchService`	文件系统监听，实时检测文件 / 目录变化

2. 示例

java 复制代码

// 1. 读取文本文件（一行代码）
String content = Files.readString(Paths.get("test.txt"), StandardCharsets.UTF_8);

// 2. 写入文本文件
Files.write(Paths.get("test.txt"), "Hello NIO.2".getBytes(StandardCharsets.UTF_8));

// 3. 遍历目录
Files.walk(Paths.get("./"))
     .filter(Files::isRegularFile)
     .forEach(path -> System.out.println(path));

// 4. 监听文件变化
WatchService watchService = FileSystems.getDefault().newWatchService();
Paths.get("./").register(watchService, StandardWatchEventKinds.ENTRY_MODIFY);
WatchKey key;
while ((key = watchService.take()) != null) {
    for (WatchEvent<?> event : key.pollEvents()) {
        System.out.println("文件变化：" + event.context());
    }
    key.reset();
}

六、应用场景

高性能网络框架：Netty、MINA 基于 NIO 封装，是分布式系统、微服务的通信核心；
大文件处理 ：FileChannel 的零拷贝（transferTo）适合视频、日志等大文件传输；
高并发服务器：Tomcat、Nginx（Java 实现）采用 NIO 处理百万级连接；
文件系统监控 ：NIO.2 的 WatchService 用于实时监控配置文件、日志文件变化。

总结

Java NIO 的核心是「通道 - 缓冲区 + 多路复用」：

Buffer 是数据容器，通过 position/limit/capacity 精准控制读写；
Channel 是双向传输通道，替代传统单向流；
Selector 实现单线程处理多通道，是高并发的核心；
NIO.2 简化了文件操作，成为现代 Java 文件 IO 的首选。

理解 NIO 的关键是摆脱 "流的思维"，转向 "事件驱动 + 缓冲区" 的思维 ------ 这也是高性能 Java 编程的基础。

附表：

JDK 版本	发布时间	NIO 核心变化	关键新增内容	核心价值
JDK 1.4	2002 年	首次引入 Java NIO（称为 "NIO 1"）	1. 三大核心组件：`Buffer`/`Channel`/`Selector` 2. 核心通道类`FileChannel`/`SocketChannel`/`ServerSocketChannel`/`DatagramChannel` 3. 辅助类：`Charset`/`Pipe`/`FileLock`	从 "面向流" 的 BIO 转向 "面向缓冲区" 的非阻塞 I/O，支持多路复用，解决高并发线程资源浪费问题
JDK 1.5	2004 年	NIO 1 的小幅度增强	1. `ByteBuffer`新增`put`/`get`的基本类型重载方法 2. `Selector`优化：`selectedKeys()`性能提升	优化 NIO 1 的使用体验，降低 Buffer 操作复杂度
JDK 1.6	2006 年	NIO 1 的稳定性 / 性能优化	1. `FileChannel`新增`transferTo`/`transferFrom`的零拷贝优化 2. `Selector`适配 Linux epoll 的边缘触发（ET）模式	大幅提升文件传输和网络 I/O 的性能
JDK 7	2011 年	引入 NIO.2（新 I/O 2.0，也叫 AIO）	1. 异步 I/O 框架：`AsynchronousChannel`/`AsynchronousSocketChannel`/`AsynchronousFileChannel` 2. 增强文件操作：`Path`/`Files`/`FileSystem`（替代`java.io.File`） 3. 异步通道组：`AsynchronousChannelGroup`	支持 "异步非阻塞 I/O"，进一步降低高并发场景的线程依赖；统一文件系统操作 API
JDK 8	2014 年	NIO.2 的 Lambda 适配 + 性能优化	1. `Files`类新增 Lambda 风格方法（如`walk`/`find`） 2. `ByteBuffer`支持`java.time`时间类型3. 异步通道的回调接口支持函数式编程	结合 Lambda 简化 NIO.2 的代码编写，提升开发效率
JDK 9	2017 年	NIO 的模块化 + 工具类增强	1. NIO 组件迁移到`java.base`模块（无需额外依赖） 2. `Buffer`新增`flip()`/`rewind()`的链式调用支持 3. `Selector`新增`select(Consumer<SelectionKey>)`简化事件处理	适配模块化（Module）架构，优化 Buffer 和 Selector 的使用体验
JDK 11	2018 年	NIO.2 的 HTTP/2 支持 + 工具类增强	1. 引入`HttpClient`（基于 NIO.2 异步通道，替代`HttpURLConnection`） 2. `Files`新增`readString`/`writeString`（直接读写字符串） 3. `ByteBuffer`新增`asReadOnlyBuffer()`的类型安全支持	原生支持 HTTP/2，大幅简化文件字符串读写操作
JDK 17（LTS）	2021 年	NIO 性能优化 + 安全增强	1. `FileChannel`优化大文件传输的零拷贝性能 2. 异步通道新增 TLS 1.3 支持 3. `Selector`修复多线程并发安全问题	提升生产环境下 NIO 的稳定性、性能和安全性
JDK 21（LTS）	2023 年	虚拟线程适配 NIO	1. 异步通道自动适配虚拟线程（`AsynchronousChannel`绑定虚拟线程执行器） 2. `Selector`优化虚拟线程下的事件唤醒逻辑	结合虚拟线程，进一步降低高并发 I/O 的资源消耗