@ -0,0 +1,393 @@
---
title: Java NIO 核心知识总结
category: Java
tag:
- Java IO
- Java基础
---
在学习 NIO 之前，需要先了解一下计算机 I/O模型的基础理论知识。还不了解的话， ： Java IO 模型详解 ](https://javaguide.cn/java/io/io-model.html )。
## NIO 简介
在传统的 Java I/O 模型（ ） ，
为了解决这个问题， **NIO** （ ， ） ， ， ，
下图是 BIO、NIO 和 AIO 处理客户端请求的简单对比图（关于 AIO 的介绍，可以看我写的这篇文章：[Java IO 模型详解 ](https://javaguide.cn/java/io/io-model.html )，不是重点，了解即可）。
⚠️需要注意：使用 NIO 并不一定意味着高性能， ，
## NIO 核心组件
NIO 主要包括以下三个核心组件：
- **Buffer（ ） ： ，
- **Channel（ ） ： ， ，
- **Selector（ ） ：允许一个线程处理多个 Channel， ，
三者的关系如下图所示（暂时不理解没关系，后文会详细介绍）：
下面详细介绍一下这三个组件。
### Buffer（ ）
在传统的 BIO 中，数据的读写是面向流的， 分为字节流和字符流。
在Java 1.4 的 NIO库中， ， ，
`Buffer` 的子类如下图所示。其中，最常用的是 `ByteBuffer` ，它可以用来存储和操作字节数据。
你可以将 Buffer 理解为一个数组，`IntBuffer` 、`FloatBuffer` 、`CharBuffer` 等分别对应 `int[]` 、`float[]` 、`char[]` 等。
为了更清晰地认识缓冲区，我们来简单看看`Buffer` 类中定义的四个成员变量：
~~~java
public abstract class Buffer {
// Invariants: mark < = position < = limit < = capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;
}
~~~
这四个成员变量的具体含义如下：
1. 容量（`capacity` ） ： `Buffer` 可以存储的最大数据量，`Buffer` 创建时设置且不可改变；
2. 界限（`limit` ） ： `Buffer` 中可以读/写数据的边界。写模式下，`limit` 代表最多能写入的数据，一般等于 `capacity` （可以通过`limit(int newLimit) ` 方法设置）；读模式下，`limit` 等于 Buffer 中实际写入的数据大小。
3. 位置（`position` ） ： （ ） （ ） ， `position` 都会归零，这样就可以从头开始读写了。
4. 标记（`mark` ） ： `Buffer` 允许将位置直接定位到该标记处，这是一个可选属性；
并且，上述变量满足如下的关系：**0 < = mark < = position < = limit < = capacity** 。
另外， `flip()` 可以切换到读模式。如果要再次切换回写模式，可以调用 `clear()` 或者 `compact()` 方法。
`Buffer` 对象不能通过 `new` 调用构造方法创建对象 ，只能通过静态方法实例化 `Buffer` 。
这里以 `ByteBuffer ` 为例进行介绍：
~~~java
// 分配堆内存
public static ByteBuffer allocate(int capacity);
// 分配直接内存
public static ByteBuffer allocateDirect(int capacity);
~~~
Buffer 最核心的两个方法：
1. `get` : 读取缓冲区的数据
2. `put` ：向缓冲区写入数据
除上述两个方法之外，其他的重要方法：
- `flip` ：将缓冲区从写模式切换到读模式，它会将 `limit` 的值设置为当前 `position` 的值，将 `position` 的值设置为 0。
- `clear` : 清空缓冲区，将缓冲区从读模式切换到写模式，并将 `position` 的值设置为 0， `limit` 的值设置为 `capacity` 的值。
- ......
Buffer 中数据变化的过程：
~~~java
import java.nio.*;
public class CharBufferDemo {
public static void main(String[] args) {
// 分配一个容量为8的CharBuffer
CharBuffer buffer = CharBuffer.allocate(8);
System.out.println("初始状态：");
printState(buffer);
// 向buffer写入3个字符
buffer.put('a').put('b').put('c');
System.out.println("写入3个字符后的状态：
printState(buffer);
// 调用flip()方法， ，
buffer.flip();
System.out.println("调用flip()方法后的状态：");
printState(buffer);
// 读取字符
while (buffer.hasRemaining()) {
System.out.print(buffer.get());
}
// 调用clear()方法，清空缓冲区，将 position 的值置为 0，
buffer.clear();
System.out.println("调用clear()方法后的状态：");
printState(buffer);
}
// 打印buffer的capacity、limit、position、mark的位置
private static void printState(CharBuffer buffer) {
System.out.print("capacity: " + buffer.capacity());
System.out.print(", limit: " + buffer.limit());
System.out.print(", position: " + buffer.position());
System.out.print(", mark 开始读取的字符: " + buffer.mark());
System.out.println("\n");
}
}
~~~
输出:
~~~bash
初始状态：
capacity: 8, limit: 8, position: 0
写入3个字符后的状态：
capacity: 8, limit: 8, position: 3
准备读取buffer中的数据！
调用flip()方法后的状态：
capacity: 8, limit: 3, position: 0
读取到的数据：
调用clear()方法后的状态：
capacity: 8, limit: 8, position: 0
~~~
为了帮助理解，我绘制了一张图片展示 `capacity` 、`limit` 和`position` 每一阶段的变化。
### Channel（ ）
Channel 是一个通道，它建立了与数据源（如文件、网络套接字等）之间的连接。我们可以利用它来读取和写入数据，就像打开了一条自来水管，让数据在 Channel 中自由流动。
BIO 中的流是单向的，分为各种 `InputStream` （输入流）和 `OutputStream` （输出流），数据只是在一个方向上传输。通道与流的不同之处在于通道是双向的，它可以用于读、写或者同时用于读写。
Channel 与前面介绍的 Buffer 打交道，读操作的时候将 Channel 中的数据填充到 Buffer中，
另外，因为 Channel 是全双工的，所以它可以比流更好地映射底层操作系统的 API。特别是在 UNIX 网络编程模型中，底层操作系统的通道都是全双工的，同时支持读写操作。
`Channel` 的子类如下图所示。
其中，最常用的是以下几种类型的通道：
- `FileChannel` ：文件访问通道；
- `SocketChannel` 、`ServerSocketChannel` ： ；
- `DatagramChannel` ：
Channel 最核心的两个方法：
1. `read` ：用于从 Buffer 中读取数据；
2. `write` ：向 Buffer 中写入数据。
这里我们以 `FileChannel` 为例演示一下是读取文件数据的。
~~~java
RandomAccessFile reader = new RandomAccessFile("/Users/guide/Documents/test_read.in", "r"))
FileChannel channel = reader.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
~~~
### Selector（ ）
Selector（ ） ， ， ， ： ， ，
一个多路复用器 Selector 可以同时轮询多个 Channel， `epoll()` 代替传统的 `select` 实现，所以它并没有最大连接句柄 `1024/2048` 的限制。这也就意味着只需要一个线程负责 Selector 的轮询，就可以接入成千上万的客户端。
Selector 可以监听以下四种事件类型：
1. `SelectionKey.OP_ACCEPT` ：表示通道接受连接的事件，这通常用于 `ServerSocketChannel` 。
2. `SelectionKey.OP_CONNECT` ：表示通道完成连接的事件，这通常用于 `SocketChannel` 。
3. `SelectionKey.OP_READ` ：表示通道准备好进行读取的事件，即有数据可读。
4. `SelectionKey.OP_WRITE` ：表示通道准备好进行写入的事件，即可以写入数据。
`Selector ` 是抽象类，可以通过调用此类的 `open()` 静态方法来创建 Selector 实例。Selector 可以同时监控多个 `SelectableChannel` 的 `IO` 状况，是非阻塞 `IO` 的核心。
一个Selector 实例有三个 `SelectionKey` 集合：
1. 所有的 `SelectionKey` 集合：代表了注册在该 Selector 上的 `Channel` ，这个集合可以通过 `keys()` 方法返回。
2. 被选择的 `SelectionKey` 集合：代表了所有可通过 `select()` 方法获取的、需要进行 `IO` 处理的 Channel， `selectedKeys()` 返回。
3. 被取消的 `SelectionKey` 集合：代表了所有被取消注册关系的 `Channel` ，在下一次执行 `select()` 方法时，这些 `Channel` 对应的 `SelectionKey` 会被彻底删除，程序通常无须直接访问该集合，也没有暴露访问的方法。
简单演示一下如何遍历被选择的 `SelectionKey` 集合并进行处理：
```java
Set< SelectionKey > selectedKeys = selector.selectedKeys();
Iterator< SelectionKey > keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key != null) {
if (key.isAcceptable()) {
// ServerSocketChannel 接收了一个新连接
} else if (key.isConnectable()) {
// 表示一个新连接建立
} else if (key.isReadable()) {
// Channel 有准备好的数据，可以读取
} else if (key.isWritable()) {
// Channel 有空闲的 Buffer，
}
}
keyIterator.remove();
}
```
Selector 还提供了一系列和 `select()` 相关的方法：
- `int select()` ：监控所有注册的 `Channel` ，当它们中间有需要处理的 `IO` 操作时，该方法返回，并将对应的 `SelectionKey` 加入被选择的 `SelectionKey` 集合中，该方法返回这些 `Channel` 的数量。
- `int select(long timeout)` ：可以设置超时时长的 `select()` 操作。
- `int selectNow()` ：执行一个立即返回的 `select()` 操作，相对于无参数的 `select()` 方法而言，该方法不会阻塞线程。
- `Selector wakeup()` ：使一个还未返回的 `select()` 方法立刻返回。
- ......
使用 Selector 实现网络读写的简单示例：
~~~java
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 NioSelectorExample {
public static void main(String[] args) {
try {
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.socket().bind(new InetSocketAddress(8080));
Selector selector = Selector.open();
// 将 ServerSocketChannel 注册到 Selector 并监听 OP_ACCEPT 事件
serverSocketChannel.register(selector, SelectionKey.OP_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()) {
// 处理连接事件
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel client = server.accept();
client.configureBlocking(false);
// 将客户端通道注册到 Selector 并监听 OP_READ 事件
client.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
// 处理读事件
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = client.read(buffer);
if (bytesRead > 0) {
buffer.flip();
System.out.println("收到数据：" +new String(buffer.array(), 0, bytesRead));
// 将客户端通道注册到 Selector 并监听 OP_WRITE 事件
client.register(selector, SelectionKey.OP_WRITE);
} else if (bytesRead < 0 ) {
// 客户端断开连接
client.close();
}
} else if (key.isWritable()) {
// 处理写事件
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.wrap("Hello, Client!".getBytes());
client.write(buffer);
// 将客户端通道注册到 Selector 并监听 OP_READ 事件
client.register(selector, SelectionKey.OP_READ);
}
keyIterator.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
~~~
在示例中， ， ，
## NIO 零拷贝
零拷贝是提升 IO 操作性能的一个常用手段，像 ActiveMQ、Kafka 、RocketMQ、QMQ、Netty 等顶级开源项目都用到了零拷贝。
零拷贝是指计算机执行 IO 操作时， `mmap+write` 、`sendfile` 和 `sendfile + DMA gather copy` 。
下图展示了各种零拷贝技术的对比图：
| | CPU 拷贝 | DMA 拷贝 | 系统调用 | 上下文切换 |
| -------------------------- | -------- | -------- | ---------- | ---------- |
| 传统方法 | 2 | 2 | read+write | 4 |
| mmap+write | 1 | 2 | mmap+write | 4 |
| sendfile | 1 | 2 | sendfile | 2 |
| sendfile + DMA gather copy | 0 | 2 | sendfile | 2 |
可以看出，无论是传统的 I/O 方式， ，
Java 对零拷贝的支持：
- `MappedByteBuffer` 是 NIO 基于内存映射（`mmap` ）这种零拷⻉⽅式的提供的⼀种实现，底层实际是调用了 Linux 内核的 `mmap` 系统调用。它可以将一个文件或者文件的一部分映射到内存中，形成一个虚拟内存文件，这样就可以直接操作内存中的数据，而不需要通过系统调用来读写文件。
- `FileChannel` 的`transferTo()/transferFrom()` 是 NIO 基于发送文件（`sendfile` ）这种零拷贝方式的提供的一种实现，底层实际是调用了 Linux 内核的 `sendfile` 系统调用。它可以直接将文件数据从磁盘发送到网络，而不需要经过用户空间的缓冲区。关于`FileChannel` 的用法可以看看这篇文章：[Java NIO 文件通道 FileChannel 用法 ](https://www.cnblogs.com/robothy/p/14235598.html )。
代码示例：
```java
private void loadFileIntoMemory(File xmlFile) throws IOException {
FileInputStream fis = new FileInputStream(xmlFile);
// 创建 FileChannel 对象
FileChannel fc = fis.getChannel();
// FileChannle.map() 将文件映射到直接内存并返回 MappedByteBuffer 对象
MappedByteBuffer mmb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
xmlFileBuffer = new byte[(int)fc.size()];
mmb.get(xmlFileBuffer);
fis.close();
}
```
## 总结
这篇文章我们主要介绍了 NIO 的核心知识点，包括 NIO 的核心组件和零拷贝。
如果我们需要使用 NIO 构建网络程序的话，不建议直接使用原生 NIO， ，
## 参考
- Java NIO浅析： < https: / / tech . meituan . com / 2016 / 11 / 04 / nio . html >
- 面试官： ？
- Java NIO： ：
