NIO组件之Buffer详解

最新推荐文章于 2024-03-13 10:00:00 发布

逆天至尊

最新推荐文章于 2024-03-13 10:00:00 发布

阅读量1k

点赞数 1

分类专栏：高并发文章标签： nio java jvm

本文链接：https://blog.csdn.net/ntzzzsj/article/details/125928191

版权

高并发专栏收录该内容

6 篇文章 0 订阅

订阅专栏

NIO的Buffer（缓冲区）本质上是一个内存块，既可以写入数据，也可以从中读取数据。Java NIO中代表缓冲区的Buffer类是一个抽象类，位于java.nio包中。

NIO的Buffer的内部是一个内存块（数组），此类与普通的内存块（Java数组）不同的是：NIO Buffer对象，提供了一组比较有效的方法，用来进行写入和读取的交替访问。

Buffer类

Buffer类是一个抽象类，同时也是一个非线程安全类，对应于Java的主要数据类型，在NIO中有8种缓冲区类，分别如下：ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、 ShortBuffer、MappedByteBuffer。

前7种Buffer类型，覆盖了能在IO中传输的所有的Java基本数据类型。第8种类型MappedByteBuffer是专门用于内存映射的一种ByteBuffer类型。不同的Buffer子类，其能操作的数据类型能够通过名称进行判断，比如IntBuffer只能操作Integer类型的对象。

实际上，使用最多的还是ByteBuffer二进制字节缓冲区类型

Buffer类的重要属性

Buffer的子类会拥有一块内存，作为数据的读写缓冲区，但是读写缓冲区并没有定义在Buffer基类，而是定义在具体的子类中。如ByteBuffer子类就拥有一个byte[]类型的数组成员final byte[] hb，作为自己的读写缓冲区，数组的元素类型与Buffer子类的操作类型相互对应。

为了记录读写的状态和位置，Buffer类额外提供了一些重要的属性，其中有以下三个重要的成员属性：

capacity（容量）
position（读写位置）
limit（读写的限制）
mark （读写位置的临时备份）

四个成员属性详细介绍

1、capacity属性

Buffer类的capacity属性，表示内部容量的大小。一旦写入的对象数量超过了capacity容量，缓冲区就满了，不能再写入了。

Buffer类的capacity属性一旦初始化，就不能再改变。原因是什么呢？Buffer类的对象在初始化时，会按照capacity分配内部数组的内存，在数组内存分配好之后，它的大小当然就不能改变了。

Buffer类是一个抽象类，Java不能直接用来新建对象。在具体使用的时候，必须使用Buffer的某个子类，例如DoubleBuffer子类，该子类能写入的数据类型是double类型，如果在创建实例时其capacity是100，那么我们最多可以写入100个double类型的数据。

capacity 容量并不是指内部的内存块 byte[]数组的字节数量，而是指能写入的数据对象的最大限制数量。

2、position属性

Buffer类的position属性，表示当前的位置。position属性的值与缓冲区的读写模式有关。在不同的模式下，position属性值的含义是不同的，在缓冲区进行读写的模式改变时，position值会进行相应的调整。

在写入模式下，position的值变化规则如下：

在刚进入到写入模式时，position值为0，表示当前的写入位置为从头开始。
每当一个数据写到缓冲区之后，position会向后移动到下一个可写的位置。
初始的position值为0，最大可写值为limit–1。当position值达到limit时，缓冲区就已经无空间可写了。

在读模式下，position的值变化规则如下：

当缓冲区刚开始进入到读取模式时，position会被重置为0。
当从缓冲区读取时，也是从position位置开始读。读取数据后，position向前移动到下一个可读的位置。
在读模式下，limit表示可以读上限。position的最大值，为最大可读上限limit，当position达到limit时，表明缓冲区已经无数据可读。

Buffer的读写模式切换:当新建了一个缓冲区实例时，缓冲区处于写入模式，这时是可以写数据的。在数据写入完成后，如果要从缓冲区读取数据，这就要进行模式的切换，可以使用（即调用）flip翻转方法，将缓冲区变成读取模式。

在从写入模式到读取模式的flip翻转过程中，position和limit属性值会进行调整，具体的规则是：

limit属性被设置成写入模式时的position值，表示可以读取的最大数据位置；
position由原来的写入位置，变成新的可读位置，也就是0，表示可以从头开始读。

3、limit属性

Buffer类的limit属性，表示可以写入或者读取的最大上限，其属性值的具体含义，也与缓冲区的读写模式有关，在不同的模式下，limit的值的含义是不同的，具体分为以下两种情况：

在写入模式下，limit属性值的含义为可以写入的数据最大上限。在刚进入到写入模式时，limit的值会被设置成缓冲区的capacity容量值，表示可以一直将缓冲区的容量写满。
在读取模式下，limit的值含义为最多能从缓冲区中读取到多少数据。

一般情况下，在进行缓冲区操作时，是先写入然后再读取的。当缓冲区写入完成后，就可以开始从Buffer读取数据，可以使用flip翻转方法，这时，limit的值也会进行调整。此时会将写入模式下的position值，设置成读取模式下的limit值，也就是说，将之前写入的最大数量，作为可以读取的上限值。

Buffer在flip翻转时的属性值调整，主要涉及position、limit两个属性，但是这种调整比较微妙，不是太好理解，下面是一个简单例子：

创建缓冲区。新创建的缓冲区处于写入模式，其position值为0，limit值为最大容量capacity。
向缓冲区写数据。每写入一个数据，position向后面移动一个位置，也就是position的值加1。这里假定写入了5个数，当写入完成后，position的值为5。
使用flip方法将缓冲区切换到读模式。limit的值，先会被设置成写入模式时的position值，所以新的limit值是5，表示可以读取的最大上限是5。之后调整position值，新的position会被重置为0，表示可以从0开始读。
缓冲区切换到读模式后，就可以从缓冲区读取数据了，一直到缓冲区的数据读取完毕。

4、mark属性

mark属性的大致作用为：读位置或者写位置的一个备份，供后续恢复时使用。在缓冲区操作（读或者写）的过程当中，可以将当前的position的值，临时存入mark属性中；需要恢复的时候，可以再从mark中取出之前的值，恢复到position属性中，然后，后续可以重新从position位置开始处理（读取或者写入）。

5、属性总结

属性	说明
capacity	容量，即可以容纳的最大数据量；在缓冲区创建时设置并且不能改变
limit	上限，缓冲区中当前的数据量
position	位置，缓冲区中下一个要被读或写的元素的索引
mark	调用 mark()方法来设置 mark=position，再调用 reset()可以让 position 恢复到 mark标记的位置，即 position=mark

NIO Buffer类的重要方法

allocate()创建缓冲区

在使用Buffer（缓冲区）实例之前，我们首先需要获取Buffer子类的实例对象，并且分配内存空间。如果需要获取一个Buffer实例对象，并不是使用子类的构造器来创建一个实例对象，而是调用子类的allocate()方法。

public class BufferTest {

    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(20);
        System.out.println("position： "+intBuffer.position());
        System.out.println("limit： "+intBuffer.limit());
        System.out.println("capacity： "+intBuffer.capacity());
    }
}

以上例子中，IntBuffer是具体的Buffer子类，通过调用IntBuffer.allocate(20)，创建了一个Intbuffer实例对象，并且分配了20 * 4个字节的内存空间。缓冲区的内部结构如下：

运行结果如下：

从上面的运行结果，可以看出：一个缓冲区在新建后，处于写入的模式，position属性（代表写入位置）的值为0，缓冲区的capacity容量值也是初始化时allocate方法的参数值（这里是20），而limit最大可写上限值也为的allocate方法的初始化参数值。

put()写入到缓冲区

在调用allocate方法分配内存、返回了实例对象后，缓冲区实例对象处于写模式，可以写入对象，而如果要写入对象到缓冲区，需要调用put方法。put方法很简单，只有一个参数，即为所需要写入的对象。只不过，写入的数据类型要求与缓冲区的类型保持一致。

比如下面的例子，向刚刚创建的intBuffer缓存实例对象中，写入的5个整数，代码如下：

 public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(20);
        Flux.range(0,5).toStream().forEach(i->{
            intBuffer.put(i);
        });
        System.out.println("position： "+intBuffer.position());
        System.out.println("limit： "+intBuffer.limit());
        System.out.println("capacity： "+intBuffer.capacity());
 }

此时，缓冲区的内部结构如下：

其运行结果如下：

从结果可以看到，写入了5个元素之后，缓冲区的position属性值变成了5，所以指向了第6个（从0开始的）可以进行写入的元素位置。而limit最大可写上限、capacity最大容量两个属性的值，都没有发生变化。

flip()翻转

向缓冲区写入数据之后，这时缓冲区还处于写模式，如果需要读取数据，还需要将缓冲区转换成读模式。flip()翻转方法是Buffer类提供的一个模式转变的重要方法，它的作用就是将写入模式翻转成读取模式。

如以下示例：

    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(20);
        Flux.range(0,5).toStream().forEach(i->{
            intBuffer.put(i);
        });
        System.out.println("position before： "+intBuffer.position());
        System.out.println("limit before： "+intBuffer.limit());
        System.out.println("capacity before： "+intBuffer.capacity());
        System.out.println("mark before:  "+intBuffer.mark());
        intBuffer.flip();
        System.out.println("position after： "+intBuffer.position());
        System.out.println("limit after： "+intBuffer.limit());
        System.out.println("capacity after： "+intBuffer.capacity());
        System.out.println("mark after:  "+intBuffer.mark());
    }

调用flip方法进行缓冲区的模式翻转之后，缓冲区的内部结构如下：

运行结果如下：

调用flip方法后，新模式下可读上限limit的值，变成了之前写入模式下的position属性值，也就是5；而新的读取模式下的position值，简单粗暴地变成了0，表示从头开始读取。

设置可读上限limit的属性值。将写入模式下的缓冲区中内容的最后写入位置position值，作为读取模式下的limit上限值。
把读的起始位置position的值设为0，表示从头开始读。
清除之前的mark标记，因为mark保存的是写入模式下的临时位置，发生模式翻转后，如果继续使用旧的mark标记，会造成位置混乱。

Buffer.flip()方法的源代码如下：

public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
}

当我们在读取完成后，想再一次将缓冲区切换成写入模式时，可以调用Buffer.clear() 清空或者Buffer.compact()压缩方法，它们可以将缓冲区转换为写模式。总体的Buffer模式转换，大致如下图所示：

clear()与compact()方法的区别：

如果调用的是clear()方法，position将被设回0，limit被设置成 capacity的值。换句话说，Buffer 被清空了。Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。

如果Buffer中有一些未读的数据，调用clear()方法，数据将“被遗忘”，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。

如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。

compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。

get()从缓冲区读取

使用调用flip方法将缓冲区切换成读取模式之后，就可以开始从缓冲区中进行数据读取了。读取数据的方法很简单，可以调用get方法每次从position的位置读取一个数据，并且进行相应的缓冲区属性的调整。

如以下示例：

   public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(20);
        Flux.range(0,5).toStream().forEach(i->{
            intBuffer.put(i);
        });
        intBuffer.flip();
        Flux.range(0,2).toStream().forEach(i->{
            intBuffer.get();
        });
        System.out.println("position before： "+intBuffer.position());
        System.out.println("limit before： "+intBuffer.limit());
        System.out.println("capacity before： "+intBuffer.capacity());
        System.out.println("mark before:  "+intBuffer.mark());
}

其运行结果如下：

从程序的输出结果，我们可以看到，读取操作会改变可读位置position的属性值，而limit可读上限值并不会改变。在position值和limit的值相等时，表示所有数据读取完成，position指向了一个没有数据的元素位置，已经不能再读了。此时再读，会抛出BufferUnderflowException异常。

但是在读完之后不可以立即对缓冲区进行数据写入，因为现在还处于读取模式，我们必须调用Buffer.clear()或Buffer.compact()方法，即清空或者压缩缓冲区，将缓冲区切换成写入模式，让其重新可写。

rewind()倒带

已经读完的数据，如果需要再读一遍，可以调用rewind()方法。rewind()也叫倒带，就像播放磁带一样倒回去，再重新播放。如以下示例：

    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(20);
        Flux.range(0,5).toStream().forEach(i->{
            intBuffer.put(i);
        });
        intBuffer.flip();
        Flux.range(0,2).toStream().forEach(i->{
            intBuffer.get();
        });
        intBuffer.rewind();
        System.out.println("position before： "+intBuffer.position());
        System.out.println("limit before： "+intBuffer.limit());
        System.out.println("capacity before： "+intBuffer.capacity());
        System.out.println("mark before:  "+intBuffer.mark());
}

其运行结果如下：

rewind ()方法，主要是调整了缓冲区的position属性与mark标记属性，具体的调整规则如下：

position重置为0，所以可以重读缓冲区中的所有数据；
limit保持不变，数据量还是一样的，仍然表示能从缓冲区中读取的元素数量；
mark标记被清理，表示之前的临时位置不能再用了。

Buffer.rewind()方法的源代码如下：

public final Buffer rewind() {
        position = 0;
        mark = -1;
        return this;
}

通过源代码，我们可以看到rewind()方法与flip()很相似，区别在于：倒带方法rewind()不会影响limit属性值；而翻转方法flip()会重设limit属性值。

mark( )和reset( )

mark( )和reset( )两个方法是成套使用的：Buffer.mark()方法将当前position的值保存起来，放在mark属性中，让mark属性记住这个临时位置；之后，可以调用Buffer.reset()方法将mark的值恢复到position中。

Buffer.mark()和 Buffer.reset()两个方法都涉及到 mark 属性的使用。mark()方法与 mark 属性，二者的名字虽然相同，但是一个是 Buffer 类的成员方法，另一个是 Buffer类的成员属性，不能混淆。

比如在读到第3个元素（i为2时）时，可以调用mark()方法，把当前位置position的值保存到mark属性中，这时mark属性的值为2。然后，就可以调用reset( )方法，将mark属性的值恢复到position中，这样就可以从位置2（第三个元素）开始重复读取。

clear( )清空缓冲区

在读取模式下，调用clear()方法将缓冲区切换为写入模式。此方法的作用：

会将position清零；
limit设置为capacity最大容量值，可以一直写入，直到缓冲区写满。

使用Buffer类的基本步骤

使用创建子类实例对象的allocate( )方法，创建一个Buffer类的实例对象。
调用put( )方法，将数据写入到缓冲区中。
写入完成后，在开始读取数据前，调用Buffer.flip( )方法，将缓冲区转换为读模式。
调用get( )方法，可以从缓冲区中读取数据。
读取完成后，调用Buffer.clear( )方法或Buffer.compact()方法，将缓冲区转换为写入模式，可以继续写入。

逆天至尊

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
1
评论
NIO组件之Buffer详解

Buffer类的capacity属性，表示内部容量的大小。一旦写入的对象数量超过了capacity容量，缓冲区就满了，不能再写入了。Buffer类的capacity属性一旦初始化，就不能再改变。原因是什么呢？Buffer类的对象在初始化时，会按照capacity分配内部数组的内存，在数组内存分配好之后，它的大小当然就不能改变了。Buffer类是一个抽象类，Java不能直接用来新建对象。属性说明capacity容量，即可以容纳的最大数据量；在缓冲区创建时设置并且不能改变limit。...
复制链接

扫一扫