Java NIO原理机制详解

JavaWizard-M

于 2023-04-28 11:55:45 发布

阅读量1.2k

点赞数

文章标签： java nio jvm

本文链接：https://blog.youkuaiyun.com/java_cpp_/article/details/130423640

版权

Java NIO原理机制

什么是NIO

Java NIO（New IO）是Java 1.4版本引入的一个新的IO API，与传统的Java IO有着同样的作用和目的，但是使用方式完全不同。NIO支持面向缓冲区的、基于通道的IO操作，可以提供比传统IO更高效、更灵活的IO操作方式，适用于高并发、大吞吐量的场景。

相比于传统的流式IO，NIO利用了基于缓存区的思路，将数据先读取到一个固定大小的缓存区中，然后再从缓存区中读取或写入数据，因此可以避免频繁地进行系统调用和上下文切换，从而提高了IO的效率。

NIO的实现原理

基本组件

Java NIO系统的核心在于通道（Channel）和缓冲区（Buffer）。通道表示打开到IO设备（如文件、套接字）的连接，缓冲区用于容纳数据进行处理。NIO的基本组件如下：

Channel：数据通道，类似于水管，用于读取和写入数据，可以理解为是一个双向的通道。
Buffer：缓存区，用于缓存数据，可以看成一块内存块，实际上是自动扩展的byte数组。
Selector：选择器，用于监听Channel上的IO事件，例如连接请求、数据到达等。

实现原理

NIO的实现原理主要基于以下几个方面：

缓存区（Buffer）

缓存区是NIO的一个核心组件，在缓存区中可以存储读取或写入的数据，缓冲区类别如下：

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

缓存区的操作主要包括两种：put和get。put操作将数据从外部写入缓冲区，get操作则将数据从缓冲区读取到外部。

通道（Channel）

通道表示打开到IO设备（如文件、套接字）的连接，可以读取和写入数据。通道主要分为两大类：

FileChannel：文件通道，用于文件的读写操作。
SocketChannel/ServerSocketChannel ：网络通道，用于网络IO操作。

通道的读写操作主要通过Buffer进行，如下所示：

// 读取文件通道数据
FileInputStream fis = new FileInputStream("file.txt");
FileChannel fChannel = fis.getChannel();
ByteBuffer bBuf = ByteBuffer.allocate(1024);
int bytesRead = fChannel.read(bBuf); // 读取数据到缓冲区
while (bytesRead != -1) {
   System.out.println("Read " + bytesRead);
   bBuf.flip(); // 将缓冲区由写模式切换到读模式
   while (bBuf.hasRemaining()) {
       System.out.print((char) bBuf.get()); // 读取缓冲区数据
   }
   bBuf.clear(); // 清空缓冲区，准备下一次读取
   bytesRead = fChannel.read(bBuf);
}
fis.close();

// 写入文件通道数据
FileOutputStream fos = new FileOutputStream("file.txt");
FileChannel fChannel = fos.getChannel();
ByteBuffer bBuf = ByteBuffer.allocate(1024);
byte[] msgBytes = "Hello, NIO!".getBytes();
bBuf.put(msgBytes); // 将数据写入缓冲区
bBuf.flip(); // 将缓冲区由写模式切换到读模式
while (bBuf.hasRemaining()) {
   fChannel.write(bBuf); // 将缓冲区中的数据写入文件通道
}
fos.close();

选择器（Selector）

选择器是NIO提供的一种高效的IO多路复用机制，可以监听多个通道上的事件。在一个线程内可以同时监听多个通道的读就绪、写就绪等事件，有效地降低了多线程开发复杂度和系统开销。

选择器的基本操作如下：

调用Selector.open()创建一个Selector对象。
调用Channel.register()方法将通道注册到Selector上，并指定所需监听的IO事件。
不断调用Selector.select()方法进行选择操作，该方法会阻塞直到有对应的IO事件发生。
调用Selector.selectedKeys()方法获取Selector上已选择的IO事件集合。
通过遍历已选择的IO事件集合，处理对应的IO操作。

// 创建选择器
Selector selector = Selector.open();
// 注册通道到选择器，并指定监听事件
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
// 不断循环选择操作
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()) {
            // 处理连接接受事件
        } else if (key.isConnectable()) {
            // 处理连接就绪事件
        } else if (key.isReadable()) {
            // 处理读就绪事件
        } else if (key.isWritable()) {
            // 处理写就绪事件
        }
        keyIterator.remove();
    }
}

NIO的应用场景

NIO适用于大量连接并发、数据传输量较大的场景，例如：

高并发的网络服务器，如Web服务器。
分布式系统，如Hadoop等。
数据库连接池，提高数据库操作效率。
大文件的读写，通过内存映射的方式可以避免频繁的磁盘IO操作。

NIO实操案例

下面我们来看一个简单的NIO应用实例：基于NIO实现的Echo服务器。

服务器端代码

public class NIOServer {

    public static void main(String[] args) throws IOException {
        // 创建ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(8888));
        serverSocketChannel.configureBlocking(false);

        // 创建Selector
        Selector selector = Selector.open();
        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()) {
                    // 处理连接请求事件
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("建立新连接: " + socketChannel.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 处理读取数据事件
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    socketChannel.read(buffer);
                    buffer.flip();
                    socketChannel.write(buffer);
                }
                keyIterator.remove();
            }
        }
    }
}

客户端代码

public class NIOClient {

    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 8888));
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("Hello, NIO!".getBytes());
        buffer.flip();
        socketChannel.write(buffer);
        buffer.clear();
        socketChannel.read(buffer);
        System.out.println(new String(buffer.array()));
        socketChannel.close();
    }
}

NIO总结

Java NIO是一种面向缓存区的、基于通道的IO操作方式，可以提供比传统IO更高效、更灵活的IO操作方式，适用于高并发、大吞吐量的场景。NIO的核心组件包括通道（Channel）、缓冲区（Buffer）、选择器（Selector），NIO的实现原理主要基于这些组件之间的交互和协作。NIO的典型应用场景包括网络服务器、分布式系统、数据库连接池等。