万字扫盲ByteBuffer

太过爱你忘了你带给我的痛 2024-03-24 13:41 69阅读 0赞

### 前言 ###

已知**NIO**中有三大组件：**Channel**，**Buffer**和**Selector**。那么**Buffer**的作用就是提供一个缓冲区，用于用户程序和**Channel**之间进行数据读写，也就是用户程序中可以使用**Buffer**向**Channel**写入数据，也可以使用**Buffer**从**Channel**读取数据。

**ByteBuffer**是**Buffer**子类，是字节缓冲区，特点如下所示。

1.  **大小不可变**。一旦创建，无法改变其容量大小，无法扩容或者缩容；
2.  **读写灵活**。内部通过指针移动来实现灵活读写；
3.  支持**堆上**内存分配和**直接**内存分配。

本文将对**ByteBuffer**的相关概念，常用**API**以及使用案例进行分析。全文约1万字，知识点脑图如下。

![format_png][]

### 正文 ###

#### 一. Buffer ####

在**NIO**中，八大基础数据类型中除了**boolean**外，都有相应的**Buffer**的实现，类图如下所示。

![format_png 1][]

**Buffer**类对各种基础数据类型的缓冲区做了顶层抽象，所以要了解**ByteBuffer**，首先应该学习**Buffer**类。

1. Buffer的属性

所有缓冲区结构都有如下属性。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>int position</strong></td> 
   <td>位置索引。代表下一次将要操作的元素的位置，默认初始为0，位置索引最小为0，最大为<strong>limit</strong></td> 
  </tr> 
  <tr> 
   <td><strong>int limit</strong></td> 
   <td>限制索引。限制索引及之后的索引位置上的元素都不能操作，限制索引最小为0，最大为<strong>capacity</strong></td> 
  </tr> 
  <tr> 
   <td><strong>int capacity</strong></td> 
   <td>容量。缓冲区的最大元素个数，创建缓冲区时指定，最小为0，不能改变</td> 
  </tr> 
 </tbody> 
</table>

三者之间的大小关系应该是：**0 <= position <= limit <= capacity**，图示如下。

![format_png 2][]

除此之外，还有一个属性叫做**mark**，如下所示。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>int mark</strong></td> 
   <td>标记索引。<strong>mark</strong>会标记一个索引，在<strong>Buffer#reset</strong>调用时，将<strong>position</strong>重置为<strong>mark</strong>。<strong>mark</strong>不是必须的，但是当定义<strong>mark</strong>后，其最小为0，最大为<strong>position</strong></td> 
  </tr> 
 </tbody> 
</table>

关于**mark**还有如下两点说明。

1.  **position**或**limit**一旦小于**mark**则**mark**会被丢弃；
2.  没有定义**mark**时如果调用了**Buffer\#reset**则会抛出**InvalidMarkException**。

2. Buffer的读模式

**Buffer**有两种模式，读模式和写模式，在读模式下，可以读取缓冲区中的数据。那么对于一个缓冲区，要读取数据时，分为两步。

1.  拿到**position**位置索引；
2.  取**position**位置的数据。

那么**Buffer**提供了**nextGetIndex()** 方法和**nextGetIndex(int nb)** 方法来获取**position**，先看一下**nextGetIndex()** 方法的实现。

final int nextGetIndex() {
        // limit位置是不可操作的
        if (position >= limit) {
            throw new BufferUnderflowException();
        }
        // 返回当前position
        // 然后position后移一个位置
        return position++;
    }
    复制代码

**nextGetIndex()** 方法首先校验一下**position**是否大于等于**limit**，因为**limit**及之后的位置都是不可操作的，所以只要满足**position**大于等于**limit**则抛出异常，然后返回当前的**position**（也就是当前可操作的位置），最后**position**后移一位。

而**nextGetIndex(int nb)** 方法，则是用于**Buffer**的子类**ByteBuffer**使用，因为**ByteBuffer**的一个元素就是一个字节，而如果想要通过**ByteBuffer**获取一个整形数据，那么此时就需要连续读取四个字节。**nextGetIndex(int nb)** 方法如下所示。

final int nextGetIndex(int nb) {
        // 判断一下剩余可操作元素是否够本次获取
        if (limit - position < nb) {
            throw new BufferUnderflowException();
        }
        // 暂存当前position
        int p = position;
        // 然后position后移nb个位置
        position += nb;
        // 返回暂存的position
        return p;
    }
    复制代码

拿到**position**后，实际的读取数据，由**Buffer**的子类来实现。

3. Buffer的写模式

有读就有写，在**Buffer**的写模式下，写入数据也是分为两步。

1.  拿到**position**位置索引；
2.  写入数据到**position**位置。

写模式下，**Buffer**同样为获取**position**提供了两个方法，如下所示。

final int nextPutIndex() {
        // limit位置是不可操作的
        if (position >= limit) {
            throw new BufferOverflowException();
        }
        // 返回当前position
        // 然后position后移一个位置
        return position++;
    }
    
    final int nextPutIndex(int nb) {
        // 判断一下剩余可操作元素是否够本次写入
        if (limit - position < nb) {
            throw new BufferOverflowException();
        }
        // 暂存当前position
        int p = position;
        // 然后position后移nb个位置
        position += nb;
        // 返回暂存的position
        return p;
    }
    复制代码

同样，拿到**position**后，实际的写入数据，由**Buffer**的子类来实现。

4. Buffer读写模式切换

**Buffer**提供了读模式和写模式，同一时间**Buffer**只能在同一模式下工作，相应的，**Buffer**提供了对应的方法来做读写模式切换。

首先是读模式切换到写模式，先看如下示意图。

![format_png 3][]

上图中的情况是缓冲区中的数据已经全部被读完，那么此时如果要切换到写模式，对应的方法是**clear()** 方法，如下所示。

public final Buffer clear() {
        // 重置position为0
        position = 0;
        // 设置limit为capacity
        limit = capacity;
        // 重置mark为-1
        mark = -1;
        return this;
    }
    复制代码

注意，虽然方法名叫做**clear()**，但是实际缓冲区中的数据并没有被清除，而只是将位置索引**position**，限制索引**limit**进行了重置，同时清除了标记状态（也就是将**mark**设置为-1）。切换到写模式后，缓冲区示意图如下所示。

![format_png 4][]

然后是写模式切换到读模式，先看如下示意图。

![format_png 5][]

数据已经写入完毕了，此时如果要切换到读模式，对应的方法是**flip()**，如下所示。

public final Buffer flip() {
        // 因为position位置还没写入数据
        // 所以将position位置设置为limit
        limit = position;
        // 重置position为0
        position = 0;
        // 重置mark为-1
        mark = -1;
        return this;
    }
    复制代码

因为**position**永远代表下一个可操作的位置，那么在写模式下，**position**代表下一个写入的位置，那么其实就还没有数据写入，所以调用**flip()** 方法后，首先将**position**位置设置为**limit**，表示数据最多读取到**limit**的上一个位置，然后重置**position**和**mark**。切换到读模式后，缓冲区示意图如下所示。

![format_png 6][]

5. Buffer的rewind操作

在使用**Buffer**时，可以针对已经操作的区域进行重操作，假设缓冲区示意图如下。

![format_png 7][]

再看一下**rewind()** 方法的实现，如下所示。

public final Buffer rewind() {
        // 重置position为0
        position = 0;
        // 清除mark
        mark = -1;
        return this;
    }
    复制代码

主要就是将位置索引**position**重置为0，这样就能重新操作已经操作过的位置了，同时如果启用了**mark**，那么还会清除**mark**，也就是重置**mark**为-1。**rewind()** 方法调用后的缓冲区示意图如下所示。

![format_png 8][]

6. Buffer的reset操作

在使用**Buffer**时，可以启用**mark**来标记一个已经操作过的位置，假设缓冲区示意图如下。

![format_png 9][]

再看一下**reset()** 方法的实现，如下所示。

public final Buffer reset() {
        int m = mark;
        // 只要启用mark那么mark就不能为负数
        if (m < 0) {
            throw new InvalidMarkException();
        }
        // 将position重置为mark
        position = m;
        return this;
    }
    复制代码

在没有启用**mark**时，**mark**为-1，只要启用了**mark**，那么**mark**就不能为负数。在**reset()** 中主要就是将位置索引**position**重新设置到**mark**标记的位置，以实现对**mark**标记的位置及之后的位置进行重新操作。**reset()** 方法调用后的缓冲区示意图如下所示。

![format_png 10][]

#### 二. ByteBuffer ####

在上一节主要对**Buffer**进行了一个说明，那么本节会在上一节的基础上，对**ByteBuffer**及其实现进行学习。

1. ByteBuffer的属性

**ByteBuffer**相较于**Buffer**，多了如下三个属性。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>byte[] hb</strong></td> 
   <td>字节数组。仅<strong>HeapByteBuffer</strong>会使用到，<strong>HeapByteBuffer</strong>的数据存储在<strong>hb</strong>中</td> 
  </tr> 
  <tr> 
   <td><strong>int offset</strong></td> 
   <td>偏移量。仅<strong>HeapByteBuffer</strong>会使用到，后面会详细说明</td> 
  </tr> 
  <tr> 
   <td><strong>isReadOnly</strong></td> 
   <td>是否只读。仅<strong>HeapByteBuffer</strong>会使用到，后面会详细说明</td> 
  </tr> 
 </tbody> 
</table>

**NIO**中为**ByteBuffer**分配内存时，可以有两种方式。

1.  在堆上分配内存，此时得到**HeapByteBuffer**；
2.  在直接内存中

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b97b7ced74164e8ab705dce10e94b5ef.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/81f76fcda47d434e9082328335cec26a.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/1a5342b03aeb4fcf83fff24462817924.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f175cd6c072c452d9dc49356ad8b8b7a.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f6a662f855e044c19a09db30cfae9063.png
[format_png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/bb2cf5d2eafd43a0923b716b1a37a403.png
[format_png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/13dae1c46c3e42ffba5be6265c2f90a9.png
[format_png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/8f6e9629c3f74951b8b7aef8f056efce.png
[format_png 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/46e90e42cabe4221a5a15b321643ccaf.png
[format_png 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b6aa7ebe0ac24efb862f4ded2fb6deb6.png
[format_png 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b1ea3c33950b4831b51e4d6823a483e8.png