【Java 基础】Java 中 NIO 使用

╰半夏微凉° 2024-05-04 08:06 172阅读 0赞

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

![在这里插入图片描述][55c6848c235549b98fc1bace8deb94db.png]

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 进阶之路][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  一、什么是 NIO
         *  二、NIO 的应用场景
         *  三、Buffer的使用
         *   *  3.1、案例
         *  四、Channel的使用
         *   *  4.1、常用 API
             *  4.2、案例
         *  五、Selector的使用
         *   *  5.1、常用API
             *  5.2、案例

#### 一、什么是 NIO ####

NIO是Java中的一种非阻塞I/O（Non-blocking I/O）模型，它是Java NIO（New I/O）库的一部分。相对于传统的阻塞I/O模型，NIO提供了更高效的I/O操作方式。

NIO的核心概念是通道（Channel）和缓冲区（Buffer）。通道是数据的源和目标，而缓冲区则用于存储数据。NIO通过使用缓冲区和通道来进行数据的读写操作，实现了非阻塞的I/O。

与传统的阻塞I/O不同，NIO中的通道是双向的，可以同时用于读和写操作。而且，NIO中的通道是可以被异步地读写的，也就是说可以在数据准备好之前进行其他操作，不需要一直等待。

NIO还引入了选择器（Selector）的概念，选择器可以同时监控多个通道的事件，例如读就绪、写就绪等。通过使用选择器，可以在单个线程中处理多个通道的I/O操作，提高了系统的并发性能。

NIO是Java中一种非阻塞I/O模型，通过通道和缓冲区实现数据的读写操作，并通过选择器实现多路复用，提高了系统的并发性能。NIO在网络编程和高性能服务器开发中得到广泛应用。

#### 二、NIO 的应用场景 ####

NIO的应用场景非常广泛，特别适用于需要处理大量并发连接的网络编程和高性能服务器开发。以下是一些常见的NIO应用场景：

1.  网络编程：NIO提供了非阻塞的网络I/O操作，使得可以在一个线程中同时处理多个连接。这对于需要处理大量并发连接的服务器应用非常有用，例如聊天服务器、即时通讯服务器、游戏服务器等。
2.  高并发服务器：NIO的非阻塞I/O模型使得服务器能够高效地处理大量并发请求。通过使用选择器（Selector）和多路复用，可以在一个线程中同时处理多个通道的I/O操作，提高了服务器的并发性能。
3.  文件I/O：NIO提供了对文件的高效读写操作。通过使用通道（Channel）和缓冲区（Buffer），可以实现快速的文件读写，适用于需要处理大型文件的应用，例如日志处理、文件传输等。
4.  数据库操作：NIO可以与数据库进行高效的交互。通过使用NIO的通道和缓冲区，可以实现快速的数据库读写操作，提高了数据库操作的效率。
5.  多媒体处理：NIO可以用于处理多媒体数据，例如音频、视频等。通过使用通道和缓冲区，可以高效地读取和写入多媒体数据，适用于音视频处理、流媒体传输等应用。

NIO适用于需要处理大量并发连接、高性能服务器、文件I/O、数据库操作和多媒体处理等场景。它提供了高效的非阻塞I/O操作方式，能够提升系统的并发性能和吞吐量。

#### 三、Buffer的使用 ####

Buffer是NIO中用于存储数据的对象。它是一个固定大小的内存区域，可以用来读取数据和写入数据。

在NIO中，Buffer是通过分配一个特定大小的缓冲区来创建的。可以使用ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer和DoubleBuffer等不同类型的Buffer来存储不同类型的数据。

**Buffer有几个重要的属性**：

1.  容量（Capacity）：Buffer的容量表示它可以存储的最大数据量。
2.  位置（Position）：Buffer的位置表示当前读写的位置。初始位置为0，每次读写操作后会自动增加。
3.  上界（Limit）：Buffer的上界表示有效数据的最大位置。初始上界等于容量，随着读写操作而变化。
4.  标记（Mark）：Buffer的标记表示一个备忘位置，可以通过调用mark()方法进行设置，然后通过调用reset()方法恢复到标记位置。

Buffer提供了一系列方法来读写数据，包括put()、get()、flip()、rewind()和clear()等。其中，put()方法用于写入数据到Buffer，get()方法用于从Buffer读取数据。flip()方法将Buffer从写模式切换为读模式，rewind()方法将位置重置为0，clear()方法将位置、上界和标记重置为初始状态，但不清空数据。

**使用Buffer的一般流程是**：

1.  分配一个特定大小的缓冲区，例如ByteBuffer buffer = ByteBuffer.allocate(1024)。
2.  写入数据到Buffer，例如buffer.put(data)。
3.  调用flip()方法将Buffer从写模式切换为读模式。
4.  读取数据从Buffer，例如buffer.get()。
5.  调用clear()方法清空Buffer，准备下一次读写操作。

通过使用Buffer，可以方便地进行数据的读写操作，提高了I/O的效率。在网络编程和文件处理等场景中，Buffer的使用非常常见。

##### 3.1、案例 #####

Buffer的简单案例：

import java.nio.ByteBuffer;
    
    
    /**
     *
     * @description:  BufferExample 
     * @copyright: @Copyright (c) 2022
     * @company: Aiocloud
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-07-07 17:35
     */
    public class BufferExample {
        
        public static void main(String[] args) {
        
            // 分配一个容量为10的ByteBuffer
            ByteBuffer buffer = ByteBuffer.allocate(10);
            
            // 写入数据到Buffer
            buffer.put((byte) 1);
            buffer.put((byte) 2);
            buffer.put((byte) 3);
            
            // 切换为读模式
            buffer.flip();
            
            // 读取数据
            while (buffer.hasRemaining()) {
        
                System.out.println(buffer.get());
            }
            
            // 清空Buffer
            buffer.clear();
        }
    }

#### 四、Channel的使用 ####

Channel是NIO中用于进行数据读写的通道，它可以与文件、网络套接字等进行交互。Channel提供了高效的数据传输和处理方式，支持非阻塞的I/O操作。

##### 4.1、常用 API #####

Channel是Java NIO中的一个接口，它定义了一组用于进行数据读写的方法。下面是Channel接口的一些常用方法：

1.  `int read(ByteBuffer dst)` ：从通道读取数据到缓冲区，并返回读取的字节数。通道必须处于读模式。
2.  `int write(ByteBuffer src)` ：将缓冲区的数据写入到通道，并返回写入的字节数。通道必须处于写模式。
3.  `boolean isOpen()` ：判断通道是否打开。
4.  `void close()` ：关闭通道。
5.  `long position()` ：返回当前通道的位置。
6.  `FileChannel position(long newPosition)` ：设置当前通道的位置。
7.  `long size()` ：返回通道关联的文件的大小。
8.  `FileChannel truncate(long size)` ：截断通道关联的文件，使其变为给定大小。
9.  `FileLock lock()` ：获取通道关联的文件的独占锁。
10. `FileLock tryLock()` ：尝试获取通道关联的文件的独占锁，如果锁不可用则立即返回null。

##### 4.2、案例 #####

Channel进行文件的读写操作：

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /**
     *
     * @description:  ChannelExample
     * @copyright: @Copyright (c) 2022
     * @company: Aiocloud
     * @author: pany
     * @version: 1.0.0
     * @createTime: 2023-07-07 17:35
     */
    public class ChannelExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个输入文件流和输出文件流
                FileInputStream inputFile = new FileInputStream("input.txt");
                FileOutputStream outputFile = new FileOutputStream("output.txt");
                
                // 获取输入和输出文件的通道
                FileChannel inputChannel = inputFile.getChannel();
                FileChannel outputChannel = outputFile.getChannel();
                
                // 创建一个缓冲区
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                
                // 从输入通道读取数据到缓冲区
                while (inputChannel.read(buffer) != -1) {
        
                    buffer.flip(); // 切换为读模式
                    // 从缓冲区写入数据到输出通道
                    outputChannel.write(buffer);
                    buffer.clear(); // 清空缓冲区，准备下一次读取
                }
                
                // 关闭通道和文件流
                inputChannel.close();
                outputChannel.close();
                inputFile.close();
                outputFile.close();
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

我们首先创建了一个输入文件流和输出文件流，然后通过调用 `getChannel()` 方法获取输入和输出文件的通道。接下来，我们创建了一个ByteBuffer作为缓冲区，用于存储读取和写入的数据。然后，我们使用 `read()` 方法从输入通道读取数据到缓冲区，直到读取完所有数据。接着，我们调用 `flip()` 方法将缓冲区切换为读模式，并使用 `write()` 方法将数据从缓冲区写入到输出通道。最后，我们调用 `clear()` 方法清空缓冲区，准备下一次读取操作。最后，我们关闭了通道和文件流。

#### 五、Selector的使用 ####

Selector是Java NIO中的一个类，用于多路复用IO操作。它可以同时监控多个通道的IO事件，例如读就绪、写就绪等，并通过选择器的选择操作来处理这些事件。

##### 5.1、常用API #####

下面是Selector类的一些常用方法：

1.  `open()` ：打开一个选择器。
2.  `isOpen()` ：判断选择器是否打开。
3.  `close()` ：关闭选择器。
4.  `int select()` ：阻塞地等待通道IO事件发生，并返回就绪通道的数量。
5.  `int select(long timeout)` ：设置超时时间，阻塞地等待通道IO事件发生，并返回就绪通道的数量。
6.  `int selectNow()` ：非阻塞地等待通道IO事件发生，并返回就绪通道的数量。
7.  `Selector wakeup()` ：唤醒阻塞在select()方法上的线程。
8.  `Set<SelectionKey> selectedKeys()` ：返回当前就绪的通道对应的SelectionKey集合。
9.  `Set<SelectionKey> keys()` ：返回注册在选择器上的所有通道对应的SelectionKey集合。
10. `SelectionKey register(SelectableChannel channel, int ops)` ：将通道注册到选择器上，并指定感兴趣的IO事件。
11. `SelectionKey register(SelectableChannel channel, int ops, Object attachment)` ：将通道注册到选择器上，并指定感兴趣的IO事件和附加对象。

##### 5.2、案例 #####

Selector的案例：

1.  **服务器端**：

// 创建选择器
    Selector selector = Selector.open();
    
    // 创建服务器通道
    ServerSocketChannel serverChannel = ServerSocketChannel.open();
    serverChannel.bind(new InetSocketAddress("localhost", 8080));
    serverChannel.configureBlocking(false);
    
    // 注册通道到选择器上，并指定感兴趣的事件为接受连接
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    while (true) {
        
        // 阻塞等待IO事件发生
        selector.select();
         // 获取就绪的通道
        Set<SelectionKey> selectedKeys = selector.selectedKeys();
        for (SelectionKey key : selectedKeys) {
        
            if (key.isAcceptable()) {
        
                // 接受连接
                ServerSocketChannel server = (ServerSocketChannel) key.channel();
                SocketChannel client = server.accept();
                client.configureBlocking(false);
                client.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
        
                // 读取数据
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                client.read(buffer);
                buffer.flip();
                // 处理数据...
            }
        }
         // 清空就绪的通道
        selectedKeys.clear();
    }

1.  **客户端**：

// 创建选择器
    Selector selector = Selector.open();
    
    // 创建客户端通道
    SocketChannel clientChannel = SocketChannel.open();
    clientChannel.configureBlocking(false);
    clientChannel.connect(new InetSocketAddress("localhost", 8080));
    
    // 注册通道到选择器上，并指定感兴趣的事件为连接完成
    clientChannel.register(selector, SelectionKey.OP_CONNECT);
    
    while (true) {
        
        // 阻塞等待IO事件发生
        selector.select();
        
        // 获取就绪的通道
        Set<SelectionKey> selectedKeys = selector.selectedKeys();
        
        for (SelectionKey key : selectedKeys) {
        
            if (key.isConnectable()) {
        
                // 完成连接
                SocketChannel client = (SocketChannel) key.channel();
                if (client.isConnectionPending()) {
        
                    client.finishConnect();
                }
                
                // 发送数据...
                client.register(selector, SelectionKey.OP_WRITE);
            } else if (key.isWritable()) {
        
                // 写入数据
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer buffer = ByteBuffer.wrap("Hello, Server".getBytes());
                client.write(buffer);
                // 处理写入完成...
            }
        }
        
        // 清空就绪的通道
        selectedKeys.clear();
    }

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[55c6848c235549b98fc1bace8deb94db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/3709da3015f74964ad41eb374c940918.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center