NIO三大组件介绍及ByteBuffer的使用

分手后的思念是犯贱 2022-10-08 14:29 510阅读 0赞

# NIO三大组件 #

### 文章目录 ###

*  NIO三大组件
 *   *  一、Channel & Buffer
     *  二、Selector
     *   *  1. 多线程版设计
         *  2. 线程池版设计
         *  3. selector版设计
     *  三、ByteBuffer
     *   *  1. 基本使用
         *  2. 结构组成
         *  3. 常见方法
         *   *  3.1 分配空间
             *  3.2 写入数据
             *  3.3 读取数据
             *  3.4 标记和重置
             *  3.5 与字符串的转换
         *  4. 两个理念
         *   *  4.1 分散读取
             *  4.2 集中写入
         *  5. 黏包、半包问题练习

## 一、Channel & Buffer ##

channel 是读写数据的**双向通道**，可以从 channel 将数据读入 buffer（内存缓冲区），也可以将 buffer 的数据写入 channel，如下图所示：

![image-20210620171455345][]

**常见的Channel：**

*  FileChannel（文件传输通道）
 *  DatagramChannel（UDP传输通道）
 *  SocketChannel （TCP传输通道）
 *  ServerSocketChannel（TCP传输通道）

**常见的Buffer：**

*  ByteBuffer（抽象类）（最为常用）
    
     *  MappedByteBuffer
     *  DirectByteBuffer
     *  HeapByteBuffer
 *  ShortBuffer
 *  IntBuffer
 *  LongBuffer
 *  FloatBuffer
 *  DoubleBuffer
 *  CharBuffer

## 二、Selector ##

selector 的作用就是配合一个线程来管理多个 channel，获取这些 channel 上发生的读写事件，下面结合服务器的设计演化来理解它的用途。

### 1. 多线程版设计 ###

一台服务器要服务多个客户端，每一个客户端都要使用一个线程对其进行服务：

![image-20210620174006824][]

**缺点：**

*  内存占用高，高连接的情况下会瘫痪
 *  只适合连接数少的场景

### 2. 线程池版设计 ###

使用线程池提供的线程服务客户端：

![image-20210620174148005][]

**缺点：**

阻塞模式下，一个线程仅能处理一个 socket 连接，比如处理 socket1 的同时不能处理 socket3

### 3. selector版设计 ###

selector 的作用就是配合一个线程来管理多个 channel，获取这些 channel 上发生的读写事件，当 channel 发出请求时，selector 会通知 thread 处理这些请求：

![image-20210620174622379][]

这些 channel 工作在非阻塞模式下，channel1 中没有事件，可以去处理 channel2 或 channel3，thread 无需死等。

## 三、ByteBuffer ##

### 1. 基本使用 ###

*  向 buffer 写入数据，可以调用 `channel.read(buffer)`，从 channel 中读，向 buffer 中写
 *  如果 buffer 中写满了，需要读出，调用 `buffer.flip()` 切换至读模式，可以从 buffer 中读取数据
 *  调用 `buffer.get()` ，可以从 buffer 中读出一个字节
 *  当 buffer 中的数据全部被读出后，调用 `clear()` 或 `compact()` 切换至写模式，向buffer中再次写入数据

**代码演示：**

有一个普通文本文件 data.txt，内容为：`1234567890abcd`。

使用 `FileChannel` 来读取文件内容：

//try括号内的资源会在try语句结束后自动释放，前提是这些可关闭的资源必须实现 java.lang.AutoCloseable 接口
    
    try (RandomAccessFile file = new RandomAccessFile("data.txt", "rw")) { 
    
        //获取文件传输通道FileChannel
        FileChannel channel = file.getChannel();
    
        //划分10个字节作为ByteBuffer的缓冲区，与channel进行交互
        ByteBuffer buffer = ByteBuffer.allocate(10);
    
        do { 
    
            //向buffer写入数据，由于设置了缓冲区的大小，一次read只可以写入10个字节
            //返回值表示写入的字节数
            int len = channel.read(buffer);
    
            //如果写入的字节数为-1，表示已经到末尾
            log.debug("读到字节数：{}", len);
            if (len == -1) { 
                break;
            }
    
            //成功写入10个字节，切换至buffer的读模式，可以从缓冲区buffer中读出数据
            buffer.flip();
    
            //判断缓冲区中是否还有剩余未读数据
            while(buffer.hasRemaining()) { 
                log.debug("{}", (char)buffer.get()); //get方法一次读出一个字节
            }
    
            //读取完毕之后，切换至buffer的写模式，循环的向buffer读写数据
            buffer.clear();
    
        } while (true);
    
    } catch (IOException e) { 
        e.printStackTrace();
    }

**运行结果：**

10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数：10
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 1
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 2
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 3
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 4
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 5
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 6
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 7
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 8
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 9
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 0
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数：4
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - a
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - b
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - c
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - d
    10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数：-1

### 2. 结构组成 ###

ByteBuffer 有以下三个重要属性：

*  capacity（容量）
 *  position（读写位置的索引下标）
 *  limit（读写大小的限制）

**创建一个空的buffer：**

![image-20210620175750261][]

**调用clear，写模式下，position是写入位置，limit等于容量，下图表示写入了 4 个字节后的状态：**

![image-20210620175843653][]

**调用flip，切换到读模式，position切换为读取位置，limit切换为读取限制（改变了两个指针）：**

![image-20210620175947667][]

**读取4个字节后：**

![image-20210620180026573][]

**调用clear，切换到写模式，类似的，改变两个指针的位置（position归零）：**

![image-20210620180204117][]

**特殊情况：**

如果并没有读完，但是切换到写模式时，比如只读了前两个字节，如果调用 `compact` 方法，是把未读完的部分向前压缩，position 的位置处于向前移动后的上次未读完的数据的末尾，继续写入：

![image-20210620180443564][]

如果使用的是 `clear`方法切换到写模式，会从头开始写，将未读完的部分覆盖掉。

### 3. 常见方法 ###

#### 3.1 分配空间 ####

可以使用 `allocate` 方法为 ByteBuffer 分配空间（堆内存），其它 buffer 类也有该方法：

Bytebuffer buf = ByteBuffer.allocate(16);

这个容量大小是固定的，超出之后会报错。

#### 3.2 写入数据 ####

有两种方法：

*  调用 channel 的 `read` 方法
 *  调用 buffer 自己的 `put` 方法

int readBytes = channel.read(buffer); //返回值表示写入的字节数
    
    //或者
    
    buffer.put((byte)127);

#### 3.3 读取数据 ####

有两种办法：

*  调用 channel 的 `write` 方法，从 buffer 读，向 channel 写
 *  调用 buffer 自己的 `get` 方法

int writeBytes = channel.write(buffer); //返回值是写入channel的字节数
    
    //或者
    
    byte b = buffer.get();

**注意：**

`get` 方法会让 `position` 读指针向后走，如果想重复读取数据：

*  可以调用 `buffer.rewind()` 方法将 position 重新置为 0
 *  或者调用 `buffer.get(int i)` 方法获取索引 **i** 的内容，它不会移动读指针

#### 3.4 标记和重置 ####

`buffer.mark()` 是在读取时，在当前 position 位置做一个标记，即使 position 改变，只要调用 `buffer.reset()` 就能将 position 重置到 mark 的位置。

\*\*注意：\*\*rewind 和 flip 都会清除 mark 位置

#### 3.5 与字符串的转换 ####

//将字符串转换为ByteBuffer，转换之后自动的切换到读模式，position位于开始处
    ByteBuffer buffer1 = StandardCharsets.UTF_8.encode("你好");
    
    //将ByteBuffer转换为字符串
    CharBuffer buffer3 = StandardCharsets.UTF_8.decode(buffer1);
    String str = buffer3.toString();

### 4. 两个理念 ###

#### 4.1 分散读取 ####

假设要读取的数据的长度是已知的，分为三个部分，一次读取就将channel中的三部分数据读取到三个buffer中，如果不使用分散读取，一次将所有内容读取到buffer中，之后会进行数据的分割复制，效率不高。

**代码演示：**

有一个文本文件 `3parts.txt`，内容为：`onetwothree`。

**分散读取代码：**

try (RandomAccessFile file = new RandomAccessFile("3parts.txt", "rw")) { 
    
        FileChannel channel = file.getChannel();
    
        //给buffer分配的空间已知
        ByteBuffer a = ByteBuffer.allocate(3);
        ByteBuffer b = ByteBuffer.allocate(3);
        ByteBuffer c = ByteBuffer.allocate(5);
    
        //一次即可将数据读取到三个buffer
        channel.read(new ByteBuffer[]{ a, b, c});
    
    } catch (IOException e) { 
        e.printStackTrace();
    }

#### 4.2 集中写入 ####

一次性将多个buffer中的数据写入到channel，而不是先将多个buffer组合成一个大的buffer再写入，可以减少数据复制的次数，提高效率。

**代码演示：**

try (RandomAccessFile file = new RandomAccessFile("helloword/3parts.txt", "rw")) { 
    
        FileChannel channel = file.getChannel(); //文件中本身已有内容onetwothree
    
        //要读取的两个buffer
        ByteBuffer d = ByteBuffer.allocate(4);
        ByteBuffer e = ByteBuffer.allocate(4);
        channel.position(11);
    
        //两个buffer中新添加的数据
        d.put(new byte[]{ 'f', 'o', 'u', 'r'});
        e.put(new byte[]{ 'f', 'i', 'v', 'e'});
    
        //两个buffer切换到读模式
        d.flip();
        e.flip();
    
        //一次性将多个buffer的内容写入到channel中
        channel.write(new ByteBuffer[]{ d, e});
    
    } catch (IOException e) { 
        e.printStackTrace();
    }

运行后的文件内容：`onetwothreefourfive`。

### 5. 黏包、半包问题练习 ###

**问题描述：**

网络上有多条消息发送给服务端，消息之间使用 `\n` 进行分隔，但由于某种原因，这些信息在接收时进行了重新组合，例如原始数据有3条：

*  Hello,world\\n
 *  I’m zhangsan\\n
 *  How are you?\\n

重新组合后变成了下面的两个数据：

*  Hello,world\\nI’m zhangsan\\nHo
 *  w are you?\\n

合在一起是黏包、消息被截断是半包

现在要求编写程序，将错乱的数据恢复成原始的按 `\n` 分隔的数据。

**代码实现：**

public static void main(String[] args) { 
    
        ByteBuffer source = ByteBuffer.allocate(32);
        source.put("Hello,world\nI'm zhangsan\nHo".getBytes());
    
        split(source);
    
        source.put("w are you?\nhaha!\n".getBytes());
    
        split(source);
    }
    
    //每接收一条消息，就要从中筛选出完整的消息，不完整的消息和下一次的消息组合
    private static void split(ByteBuffer source) { 
    
        source.flip(); //要从buffer中读取数据
    
        for (int i = 0; i < source.limit(); i++) { 
            if (source.get(i) == '\n') {  //找到一条完整的信息
    
                //要将完整的消息写入新的buffer中
                //完整消息的长度是换行符索引+1-起始索引
    
                int length = i + 1 - source.position();
    
                //新buffer的长度
                ByteBuffer target = ByteBuffer.allocate(length);
    
                //向新buffer中写入
                for (int j = 0; j < length; j++) { 
                    target.put(source.get());
                }
            }
        }
    
        //原buffer读取之后，buffer还要继续写，但是不能将position归零，会把非完整的消息覆盖掉
        source.compact(); 
    }

[image-20210620171455345]: /images/20221005/c94d97abee684bf29e91ed9e12d9c913.png
[image-20210620174006824]: /images/20221005/deb0c4d5fdc64758af6a5325f5aaa8b6.png
[image-20210620174148005]: /images/20221005/1f46b94fd3cf404393493ce1e4b15d46.png
[image-20210620174622379]: /images/20221005/3e3df87a68a84950a68eff5af66049dc.png
[image-20210620175750261]: /images/20221005/e18e104f33b64a78aefe10465e0d1380.png
[image-20210620175843653]: /images/20221005/a32054637108457ba98f186fcca76aac.png
[image-20210620175947667]: /images/20221005/ef2bef0fd12348da9a6fc207489d29b5.png
[image-20210620180026573]: /images/20221005/a95766e7c8ee46ec8bc382b5337ae916.png
[image-20210620180204117]: /images/20221005/74a7f87c9f6e4dcaa2cc3c5a6a6a2ac1.png
[image-20210620180443564]: /images/20221005/dc01800e36e744bf8295ab75bb53ed31.png