探索Java NIO：究竟在哪些领域能大显身手？揭秘原理、应用场景与官方示例代码

一、NIO简介

Java NIO（New IO）是Java SE 1.4引入的一个新的IO API，它提供了比传统IO更高效、更灵活的IO操作。与传统IO相比，Java NIO的优势在于它支持非阻塞IO和选择器（Selector）等特性，能够更好地支持高并发、高吞吐量的应用场景。

上图是官方对NIO的说明，Java NIO 官方通常被称为 New I/O（新I/O），但它也因其核心功能非阻塞 I/O 特性而常常被称为 Non-blocking I/O（非阻塞 I/O）。这两个术语在讨论 Java NIO 时都是正确的，它们描述了 Java 中用于处理非阻塞 I/O 操作的机制。

二、Java I/O发展史

Java IO（Input/Output）是Java语言中用于读写数据的API，它提供了一系列类和接口，用于读取和写入各种类型的数据。下面是Java IO发展史的简要介绍：

1. JDK 1.0（1996年） 最初的Java IO只支持字节流（InputStream、OutputStream）和字符流（Reader、Writer）两种，基于阻塞式IO（BIO）模型。
2. JDK 1.1（1997年） JDK 1.1引入了NIO（New IO）包，支持了缓存区（Buffer）、通道（Channel）等概念，提供了更高效的IO操作方式，可以实现非阻塞式IO（NIO）模式。
3. JDK 1.4（2002年） JDK 1.4增加了NIO.2 API，也称为Java NIO with buffers，提供了更强大的文件处理功能和更高效的IO操作。
4. JDK 7（2011年） JDK 7引入了NIO.2的改进版——NIO.2 with Completion Ports，也称为AIO（Asynchronous IO），支持异步IO方式，在处理大量并发请求时具有优势。

三、NIO 的原理

1、核心概念

NIO 的核心概念是通道 (Channel)、缓冲区 (Buffer) 和选择器 (Selector)。

• 通道（Channel）

通道是一个用于读写数据的对象，类似于Java IO中的流（Stream）。与流不同的是，通道可以进行非阻塞式的读写操作，并且可以同时进行读写操作。通道分为两种类型：FileChannel和SocketChannel，分别用于文件和网络通信。

• 缓冲区（Buffer）

在Java NIO中，所有数据都是通过缓冲区对象进行传输的。缓冲区是一段连续的内存块，可以保存需要读写的数据。缓冲区对象包含了一些状态变量，例如容量（capacity）、限制（limit）、位置（position）等，用于控制数据的读写。

• 选择器（Selector）

选择器是Java NIO中的一个重要组件，它可以用于同时监控多个通道的读写事件，并在有事件发生时立即做出响应。选择器可以实现单线程监听多个通道的效果，从而提高系统吞吐量和运行效率。

2、原理分解

p.s.通常我们看到的图会有thread及client两部分，不太好理解nio主要应用到多个网络通信场景，所以把socketserver-->socketclient画出来就更好理解了。

说到Java NIO大家都会想到上面这张图，NIO应用程序的工作流程如下：

1. 创建通道：打开一个或多个通道，例如FileChannel、SocketChannel等。
2. 创建缓冲区：为每个通道创建一个或多个缓冲区，用于读取或写入数据。
3. 注册通道：将通道注册到选择器，以便选择器可以监控这些通道的状态。
4. 选择就绪通道：选择器等待通道就绪事件，一旦有通道准备好进行I/O操作，选择器将通知应用程序。
5. 读取/写入数据：应用程序从通道读取数据，或将数据写入通道，使用缓冲区来传输数据。

其中

• 通道和缓冲区是一对一的关系。每个通道都有一个与之对应的缓冲区，用于存储数据。
• 选择器（Selector）可以同时监视多个通道的状态。一个选择器可以绑定多个通道，以实现多路复用。

3、代码示例

在jdk的安装包里，这个路径JAVA_HOME/sample我们可以找到nio相应的示例代码。

3.1、简单操作

对于简单的文件操作，通常不需要使用选择器。传统的文件I/O操作（如文件读取和写入）可以通过FileChannel等通道进行，但它们不涉及到多路复用，因为文件读写通常是同步的，不需要监视多个通道的状态(如下面demo中的：inChannel.read(byteBuffer)本身还是一个阻塞的方法)。在这种情况下，选择器并不提供额外的好处。

以下是一个简单的Java NIO示例，演示如何从文件中读取数据并打印到控制台：

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
 
public class NIOReadFileExample {
    public static void main(String[] args) {
        // 创建通道，使用 try-with-resources 语句自动关闭资源
        try (FileInputStream inputStream = new FileInputStream("source-file-path");
             FileChannel inChannel = inputStream.getChannel()) {
             // 创建一个缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            // 使用 while 循环读取文件中的所有数据
            while (inChannel.read(byteBuffer) != -1) {
                // 切换到读模式
                byteBuffer.flip();
                // 读取缓冲区中的数据
                byte[] bytes = new byte[byteBuffer.limit()];
                byteBuffer.get(bytes);
                System.out.println(new String(bytes));
                // 清空缓冲区
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们首先打开一个文件通道，然后创建一个ByteBuffer来读取数据。我们使用read()方法从文件通道读取数据到缓冲区，然后使用flip()方法切换到读模式，遍历缓冲区并打印数据。最后，我们使用clear()方法清空缓冲区，切换到写模式，以便继续读取数据。最后，我们关闭通道以释放资源。这是一个简单的示例，实际应用中可能需要更多的错误处理和完善。

Java NIO的使用流程通常包括以下步骤：

1. 打开通道（Channel）：首先，你需要打开一个通道，可以是文件通道、套接字通道等。这通常通过FileChannel.open()或SocketChannel.open()等方法实现。
2. 创建缓冲区（Buffer）：接下来，创建一个或多个缓冲区，用于在通道和应用程序之间传输数据。常见的缓冲区包括ByteBuffer、CharBuffer、IntBuffer等。使用ByteBuffer.allocate()或ByteBuffer.allocateDirect()来创建缓冲区。
3. 读取/写入数据：使用通道的read()方法来从通道读取数据到缓冲区，或使用write()方法将数据从缓冲区写入通道。对于套接字通道，你可以通过网络发送或接收数据。
4. 缓冲区操作：对缓冲区进行操作，例如读取或写入数据。你可以使用get()方法来获取数据，使用put()方法来写入数据。
5. 切换缓冲区：在读取数据后，通常需要切换缓冲区的读模式（flip），然后开始从缓冲区读取数据。同样，在写入数据后，切换缓冲区的写模式（flip）。
6. 关闭通道：当操作完成后，关闭通道以释放资源，使用通道的close()方法来实现。

3.2、多个网络通信

对于简单的文件操作，通常不需要使用选择器。传统的文件I/O操作（如文件读取和写入）可以通过FileChannel等通道进行，但它们不涉及到多路复用，因为文件读写通常是同步的，不需要监视多个通道的状态。在这种情况下，选择器并不提供额外的好处。

在官方jdk中的exaples中我们可以看到Server有5个子类

• B1：阻塞式单线程服务器

Blocking/Single-threaded Server

B1一个阻塞式单线程服务器，在完全服务于一个连接之前不会移动到下一个连接。一个线程来处理所有客户端请求。当等待来自客户端的数据或向客户端写入数据时，服务器将阻塞。这意味着服务器一次只能处理一个客户端请求。

这种类型的服务器简单易于实现，但可扩展性差。这是因为服务器一次只能处理一个客户端请求。如果有许多客户端请求数据，服务器将无法快速响应所有请求。

• BN：阻塞式多线程服务器

Blocking/Multi-threaded Server

一个阻塞式多线程服务器，为每个连接创建一个新线程。

服务器将创建多个线程来处理客户端请求。当一个客户端连接到服务器时，服务器使用一个线程来处理该客户端的请求。

这种类型的服务器比阻塞式单线程服务器具有更好的可扩展性，但它仍然不是非常有效率，因为每个连接都需要一个单独的线程。对于大量连接来说，这会导致大量的线程开销。

• BP：阻塞式线程池服务器

Blocking/Pooled-thread Server
一个多线程服务器，为服务器使用创建一个线程池。线程池决定如何调度这些线程。服务器将创建一个线程池来处理客户端请求。当一个客户端连接到服务器时，服务器将从线程池中获取一个线程来处理该客户端的请求。当请求处理完毕后，该线程将关闭连接并返回到线程池。

• N1：非阻塞式单线程服务器

Nonblocking/Single-threaded Server

一个非阻塞式单线程服务器。所有 accept() 和 read()/write() 操作都由一个线程执行，但仅在被 Selector 选中执行这些操作后才执行。服务器将使用 Selector 来监控多个通道的就绪状态。当一个通道就绪时，服务器将从该通道读取数据或向该通道写入数据。

• N2：非阻塞式双线程服务器

Nonblocking/Dual-threaded Server

一个非阻塞式双线程服务器，在一个线程中执行 accept() 操作，在另一个线程中处理请求。这两个线程都使用 select() 函数。

以下是SocketServer、SocketClient示例代码

SocketServer

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;
 
/**
 * @Author: Hanko
 * @Date: 2023-10-12 17:42
 */
public class SelectorServer {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器套接字通道
        ServerSocketChannel socketChannel = ServerSocketChannel.open();
 
        // 将服务器套接字通道绑定到指定端口
        socketChannel.bind(new InetSocketAddress(8888));
 
        // 将服务器套接字通道设置为非阻塞模式
        socketChannel.configureBlocking(false);
 
        // 创建一个缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
 
        // 创建一个选择器
        Selector selector = Selector.open();
 
        // 将服务器套接字通道注册到选择器上，监听连接事件
        socketChannel.register(selector, SelectionKey.OP_ACCEPT);
 
        // 循环判断通道已准备好进行I/O操作
        while (selector.select() > 0) {
            // 获取所有发生的SelectionKey
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
 
            // 遍历所有SelectionKey
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                // 获取当前SelectionKey
                SelectionKey key = iterator.next();
 
                // 判断当前键的通道是否准备好接收socket连接
                if (key.isAcceptable()) {
                    // 接受客户端连接
                    SocketChannel sc = socketChannel.accept();
 
                    // 将客户端连接通道设置为非阻塞模式
                    sc.configureBlocking(false);
 
                    // 将客户端连接通道注册到选择器上，监听读事件
                    sc.register(selector, SelectionKey.OP_READ);
                    // 判断当前key的通道是否准备好读取操作
                } else if (key.isReadable()) {
                    // 获取当前key的通道
                    SocketChannel channel = (SocketChannel) key.channel();
 
                    // 从通道中读取数据到缓冲区
                    int len = 0;
                    while ((len = channel.read(buffer)) > 0) {
                        // 将缓冲区切换为读模式
                        buffer.flip();
 
                        // 打印缓冲区中的数据
                        System.out.println(new String(buffer.array(), 0, len));
 
                        // 将缓冲区重置为写模式
                        buffer.clear();
                    }
                }
 
                // 移除当前事件
                iterator.remove();
            }
        }
    }
}

SocketClient

public static void main(String[] args) throws IOException {
 
    // 获取通道、绑定主机和端口
    SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 8888));
 
    // 切换到非阻塞模式
    socketChannel.configureBlocking(false);
 
    // 创建Buffer写入数据
    ByteBuffer buffer = ByteBuffer.allocate(1024);
 
    // 将当前时间写入缓冲区
    buffer.put(new Date().toString().getBytes());
 
    // 将缓冲区切换为写模式
    buffer.flip();
 
    // 将数据写入通道
    socketChannel.write(buffer);
 
    // 关闭通道
    socketChannel.close();
}

四、NIO 的应用场景

NIO 适用于以下场景：

• 网络通信：NIO 可以用于开发高并发的网络应用，例如 Web 服务器、游戏服务器等。
• 文件操作：NIO 可以用于开发高性能的文件操作应用，例如文件传输、文件压缩等。
• 进程间通信：NIO 可以用于实现进程间通信，例如共享内存、管道等。
• 数据库操作：NIO 可以用于提高数据库操作的性能，例如批量插入、批量查询等。

1、在业务中的应用

• 聊天服务器：使用 NIO 来建立和维护多个客户端连接，并高效地处理客户端请求。
• 文件传输：使用 NIO 来高效地传输大文件。
• 数据库操作：使用 NIO 来批量插入或查询数据，提高数据库操作的性能。

2、在框架中的应用

• Netty

这是一个基于java nio实现的高性能、高可靠性的网络框架，它提供了一系列的组件和工具，用于构建异步、事件驱动的网络应用。Netty被广泛应用在互联网、大数据、游戏、通信等领域，一些著名的开源项目如Dubbo、Zookeeper、RocketMQ、Elasticsearch等都基于Netty构建 。

• Mina

这是一个基于java nio实现的轻量级网络框架，它支持TCP、UDP、SSL等协议，以及多种编解码器和过滤器。Mina可以用于开发高性能的网络服务器和客户端，一些开源项目如Apache Directory Server、Apache James等都使用了Mina 。

• Jetty

这是一个基于java nio实现的Web服务器和Servlet容器，它支持HTTP/2、WebSocket等协议，以及反应式编程模型。Jetty可以嵌入到其他应用中，提供Web服务和Web界面，一些开源项目如Eclipse、Hadoop等都使用了Jetty 。

五、优缺点

1、NIO 的优势

NIO 相对于传统 IO 具有以下优势：

• 提高并发性：NIO 可以使用多路复用器来监听多个通道的事件，提高并发性。
• 提高性能：NIO 支持非阻塞 IO，可以提高性能。
• 简化编程：NIO 的 API 更加简洁，易于理解和使用。

2、NIO 的缺点

NIO 相对于传统 IO 具有以下缺点：

• 学习成本较高：NIO 的概念和 API 与传统 IO 不同，学习成本较高。
• 不兼容性：NIO 与传统 IO 存在不兼容性，需要注意兼容性问题。

为什么NIO没有广泛的被推广起来呢？

1. 复杂性：相对于传统的阻塞式I/O，Java NIO 的编程模型更加复杂。它需要开发人员处理事件、缓冲区管理、选择器等概念，这可能会增加学习曲线，尤其是对于新手来说。
2. 性能优势局限：Java NIO 在高并发和高吞吐量的场景下可以提供性能优势，但对于许多常规应用程序而言，传统的阻塞式I/O 已经足够了。只有需要处理大量并发连接或需要高度定制化的网络通信时，Java NIO 才会显得更有价值。
3. 第三方库的竞争：有一些第三方库和框架，如Netty和Apache MINA，构建在Java NIO 之上，提供了更易于使用的高性能网络通信解决方案。这些库可能更容易推广，而不是直接使用Java NIO。
4. 历史原因：许多早期的Java应用程序是基于传统的阻塞式I/O构建的，而且迁移到Java NIO 可能需要重写或修改现有的代码。这使得许多遗留应用程序不愿意切换到新的I/O模型。