我们在上一篇博文中提到了Java IO中常见得三大模型（BIO，NIO，AIO），其中NIO是我们在日常开发中使用比较多的一种IO模型，我们今天就一起来详细的学习一下。
在传统的IO中，多以这种同步阻塞的IO模型为主，程序发起IO请求后，处理线程处于阻塞状态，直到请求的IO数据从内核空间拷贝到用户空间。如下图可以直观的体现整个流程（图源：沉默王二）。
如果发起IO的应用程序并发量不高的情况下，这种模型是没问题的。但很明显，当前的互联网中，很多应用都有高并发IO请求的情况，这时就迫切的需要一款高效的IO模型啦。
NIO中的这个N既可以命名为NEW代表一种新型的IO模型，又可以理解为Non-Blocking，非阻塞之意。Java NIO 是 Java 1.4 版本引入的，基于通道（Channel）和缓冲区（Buffer）进行操作，采用非阻塞式 IO 操作，允许线程在等待 IO 时执行其他任务。常见的 NIO 类有 ByteBuffer、FileChannel、SocketChannel、ServerSocketChannel 等。（图源：深入拆解Tomcat & Jetty）
虽然在应用发起IO请求时，之多多次发起，无须阻塞。但在内核将数据拷贝到用户空间时，还是会阻塞的，为了保证数据的准确性和系统的安全稳定。
在计算机与外部通信过程中，并非所有场景下NIO的性能都会好，对于连接少，并发地的应用系统中传统的BIO性能反而更好，因为在NIO中应用程序需要不断进行 I/O 系统调用轮询数据是否已经准备好的过程是十分消耗 CPU 资源的。
为了更好的熟悉和掌握NIO，我们这里从NIO的三大组件入手，这也是很多大厂面试官在面试时会问到的点，虽然频率不高，但一定得会！
三个核心组件：
为了更好的理解NIO基于三大核心组件的运行流程，画了一个思维导图，如下：
下面，我们针对上一章总结的三大组件，进行一个个的详细介绍。
在传统的BIO中，数据的读写操作是基于流的，写入采用输入字节流或字符流，而写出采用都的是输出字节流或者字符流，本质上都是基于字节的数据操作。而NIO库中，采用的是缓冲区，无论是写入还是写出数据，都不会进入到缓冲区里，由缓冲区进行下一步的操作。
上图是Buffer子类的继承关系结构图，我们可以看到，在Buffer中命名是基于基本数据类型的，而我们在日常使用中，ByteBuffer缓冲类最多，它是基于字节存储的，这一点和流一样。
而进入到这些缓冲类的内部够，我们可以发现，其实它们就相当于一个数组容器。在Buffer的源码中，有这样的几个参数：
public abstract class Buffer {
// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;
}
这四个成员变量的具体含义如下：
并且，上述变量满足如下的关系：0 <= mark <= position <= limit <= capacity 。
这里我们需要注意一点，Buffer拥有读和写两种模式。Buffer被创建后，默认是写模式 ，调用flip()可以切换到读模式，再调用clear()或者compact()方法切换为写模式。
1️⃣ Buffer的实例化
Buffer无法通过调用构造方法来创建对象，而是需要通过静态方法进行实例化。我们以ByteBuffer为例：
// 分配堆内存，将缓冲区建立在JVM的内存中
public static ByteBuffer allocate(int capacity);
// 分配直接内存，将缓冲区建立在物理内存中，可以提交效率。但这里的数据不会被垃圾回收，容易导致内存溢出。
public static ByteBuffer allocateDirect(int capacity);
2️⃣ Buffer的核心方法
Buffer中我们常用的方法有：
3️⃣ Buffer的测试用例
基于以上的理论知识学习后，我们写一个小的测试demo，来感受一下Buffer的使用。
【测试案例】
public class TestBuffer {
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中的数据，将 position 置 0,limit 置 3
buffer.flip();
System.out.println("调用flip()方法后的状态：");
printState(buffer);
// 读取字符
//hasRemaining()方法用于判断当前位置和限制之间是否有任何元素。
//当且仅当此缓冲区中至少剩余一个元素时，此方法才会返回true。
while (buffer.hasRemaining()) {
System.out.println("读取字符：" + buffer.get());
}
// 调用clear()方法，清空缓冲区，将 position 的值置为 0，将 limit 的值置为 capacity 的值
//调用clear()方法后，由读模式切换为写模式。
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");
}
}
【输出：】
起始状态：
capacity: 8, limit: 8, position: 0, mark 开始读取的字符:
写入3个字符后的状态：
capacity: 8, limit: 8, position: 3, mark 开始读取的字符:
调用flip()方法后的状态：
capacity: 8, limit: 3, position: 0, mark 开始读取的字符: abc
读取字符：a
读取字符：b
读取字符：c
调用clear()方法后的状态：
capacity: 8, limit: 8, position: 0, mark 开始读取的字符: abc
在上面的总结中，我们已经提过了，Channel作为一种双向的数据通道，给外部属于与程序之间搭建了一个传输的桥梁。读操作的时候将 Channel 中的数据填充到 Buffer 中，而写操作时将 Buffer 中的数据写入到 Channel 中。甚至还可以同时读写！
Channel 的子类如下图所示。
这里虽然有很多通道类，但我们在日常生活中常用的，无非是 FileChannel：文件访问通道；SocketChannel、ServerSocketChannel：TCP 通信通道；DatagramChannel：UDP 通信通道；
FileChannel：用于文件 I/O 的通道，支持文件的读、写和追加操作。FileChannel 允许在文件的任意位置进行数据传输，支持文件锁定以及内存映射文件等高级功能。FileChannel 无法设置为非阻塞模式，因此它只适用于阻塞式文件操作。
SocketChannel：用于 TCP 套接字 I/O 的通道。SocketChannel 支持非阻塞模式，可以与 Selector（下文会讲）一起使用，实现高效的网络通信。SocketChannel 允许连接到远程主机，进行数据传输。
与之匹配的有ServerSocketChannel：用于监听 TCP 套接字连接的通道。与 SocketChannel 类似，ServerSocketChannel 也支持非阻塞模式，并可以与 Selector 一起使用。ServerSocketChannel 负责监听新的连接请求，接收到连接请求后，可以创建一个新的 SocketChannel 以处理数据传输。
DatagramChannel：用于 UDP 套接字 I/O 的通道。DatagramChannel 支持非阻塞模式，可以发送和接收数据报包，适用于无连接的、不可靠的网络通信。
1️⃣ Channel的核心方法
2️⃣ Channel的测试案例
RandomAccessFile reader = new RandomAccessFile("E:\\testChannel.txt", "r");
FileChannel channel = reader.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
System.out.println("读取字符：" + new String(buffer.array()));
选择器的概念在上面已经介绍过了，我们现在主要介绍它的运作原理：
通过 Selector 注册通道的事件，Selector 会不断地轮询注册在其上的 Channel。当事件发生时，比如：某个 Channel 上面有新的 TCP 连接接入、读和写事件，这个 Channel 就处于就绪状态，会被 Selector 轮询出来。Selector 会将相关的 Channel 加入到就绪集合中。通过 SelectionKey 可以获取就绪 Channel 的集合，然后对这些就绪的 Channel 进行相应的 I/O 操作。
主要监视事件类型：
SelectionKey集合：
Selector中的select()方法：
【测试案例】
public static void main(String[] args) {
try {
//1、通过open()方法构建一个服务套接字通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
//封装8080端口
serverSocketChannel.socket().bind(new InetSocketAddress(8080));
//2、通过open方法构建一个选择器对象
Selector selector = Selector.open();
// 将 ServerSocketChannel 注册到 Selector 并监听 OP_ACCEPT 事件
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
//监听已注册的通道中是否有连接事件，并将对应的 SelectionKey 加入被选择的 SelectionKey 集合中
int readyChannels = selector.select();
if (readyChannels == 0) {
continue;
}
//通过selectedKeys返回所有需要进行 IO 处理的 Channel
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();
}
}
上面的代码创建了一个基于 Java NIO 的简单 TCP 服务器。它使用 ServerSocketChannel 和 Selector 实现了非阻塞 I/O 和 I/O 多路复用。服务器循环监听事件，当有新的连接请求时，接受连接并将新的 SocketChannel 注册到 Selector，关注 OP_READ 事件。当有数据可读时，从 SocketChannel 中读取数据并写入 ByteBuffer，然后将数据从 ByteBuffer 写回到 SocketChannel。
到这里基本上就把NIO的几个重要的组件介绍完啦，肯定不能面面俱到，大家想更多了解的，还是要多翻看不同的书籍。同时，后面我们将基于这部分内容，写一个小型的聊天室。