缓冲区

Posted 2020-09-01 皇甫哲

缓冲区

一个缓冲区对象是固定数量的数据的容器。其作用就是一个存储器，或者分段运输区，在这里数据可被存储并在之后用于检索。对于每个非布尔数据类型都有一个缓冲区类，尽管缓冲区作用于它们存储的原始数据类型，但缓冲区十分倾向于处理字节，非字节缓冲区可以在后台

执行从字节或到字节的转换，取决与缓冲区是如何创建的。

缓冲区的工作与通道紧密联系。通道是io传输发生时通过的入口，而缓冲区是这些数据传输的来源或目标。对于离开缓冲区的传输，待传递出去的数据被置于一个缓冲区，被传送到通道。待传回缓冲区的传输，一个通道将数据放置在所提供的缓冲区中。

 

Buffer类的家谱

下图是Buffer的类层次图。在顶部是通用Buffer类，Buffer定义所有缓冲区类型共有的操作，无论是它们所包含的数据类型还是可能具有的特定行为:

 

 

缓冲区基础

概念上，缓冲区是包在一个对象内的基本数据元素数组。Buffer类相比一个简单数组的优点是它将关于数据的数据内容和信息包含在一个单一的对象中，Buffer类以及它专有的子类定义了一个用于处理数据缓冲区的API。下面来看一下Buffer类所具有的属性和方法：

1、属性

所有的缓冲区都具有四个属性来提供关于其所包含的数据元素的信息，它们是：

属      性	作      用
capacity	容量，指缓冲区能够容纳的数据元素的最大数量，这一容量在缓冲区创建时被设定，并且永远不能被改变
limit	上界，指缓冲区的第一个不能被读或写的元素，或者说是，缓冲区中现存元素的计数
position	位置，指下一个要被读或写的元素的索引，位置会自动由相应的get()和put()函数更新
mark	标记，指一个备忘位置，调用mark()来设定mark=position，调用reset()来设定postion=mark，标记未设定前是未定义的

这四个属性总是遵循以下的关系：0 <= mark <= position <= limit <= capacity

2、方法

下面看一下如何使用一个缓冲区，Buffer中提供了以下的一些方法：

方      法	作      用
Object array()	返回此缓冲区的底层实现数组
int arrayOffset()	返回此缓冲区的底层实现数组中第一个缓冲区还俗的偏移量
int capacity()	返回此缓冲区的容量
Buffer clear()	清除此缓冲区
Buffer flip()	反转此缓冲区
boolean hasArray()	告知此缓冲区是否具有可访问的底层实现数组
boolean hasRemaining()	告知在当前位置和限制之间是否有元素
boolean isDirect()	告知此缓冲区是否为直接缓冲区
boolean isReadOnly()	告知此缓冲区是否为只读缓存
int limit()	返回此缓冲区的上界
Buffer limit(int newLimit)	设置此缓冲区的上界
Buffer mark()	在此缓冲区的位置设置标记
int position()	返回此缓冲区的位置
Buffer position(int newPosition)	设置此缓冲区的位置
int remaining()	返回当前位置与上界之间的元素数
Buffer reset()	将此缓冲区的位置重置为以前标记的位置
Buffer rewind()	重绕此缓冲区

关于这个API有一点值得注意的，像clear()这类函数，通常应当返回的是void而不是Buffer引用。这些函数将引用返回到它们在(this)上被引用的对象，这是一个允许级联调用的类设计方法。级联调用允许这种类型的代码：

buffer.mark();
buffer.position(5);
buffer.reset();

被简写成：

buffer.mark().position(5).reset();

 

 1 public class TestMain
 2 {
 3     /**
 4      * 待显示的字符串
 5      */
 6     private static String[] strs = 
 7     {
 8         "A random string value",
 9         "The product of an infinite number of monkeys",
10         "Hey hey we\'re the monkees",
11         "Opening act for the Monkees:Jimi Hendrix",
12         "Scuse me while I kiss this fly",
13         "Help Me! Help Me!"
14     };
15     
16     /**
17      * 标识strs的下标索引
18      */
19     private static int index = 0;
20     
21     /**
22      * 向Buffer内放置数据
23      */
24     private static boolean fillBuffer(CharBuffer buffer)
25     {
26         if (index >= strs.length)
27             return false;
28         
29         String str = strs[index++];
30         for (int i = 0; i < str.length(); i++)
31         {
32             buffer.put(str.charAt(i));
33         }
34         
35         return true;
36     }
37     
38     /**
39      * 从Buffer内把数据拿出来
40      */
41     private static void drainBuffer(CharBuffer buffer)
42     {
43         while (buffer.hasRemaining())
44         {
45             System.out.print(buffer.get());
46         }
47         System.out.println("");
48     }
49     
50     public static void main(String[] args)
51     {
52         CharBuffer cb = CharBuffer.allocate(100);
53         while (fillBuffer(cb))
54         {
55             cb.flip();
56             drainBuffer(cb);
57             cb.clear();
58         }
59     }
60 }

逐一解释一下：

1、第52行，CharBuffer是一个抽象类，它不能被实例化，因此利用allocate方法来实例化，相当于是一个工厂方法。实例化出来的是HeapCharBuffer，默认大小是100。根据上面的Buffer的类家族图谱，可以看到每个Buffer的子类都是使用allocate方法来实例化具体的子类的，且实例化出来的都是Heap*Buffer。

2、第24行~第36行，每次取String数组中的一个，利用put方法放置一个数据进入CharBuffer中

3、第55行，调用flip方法，这是非常重要的。在缓冲区被写满后，必须将其清空，但是如果现在在通道上直接执行get()方法，那么它将从我们刚刚插入的有用数据之外取出未定义数据；如果此时将位置重新设置为0，就会从正确的位置开始获取数据，但是如何知道何时到达我们所插入数据末端呢？这就是上界属性被引入的目的----上界属性指明了缓冲区有效内容的末端。因此，在读取数据的时候我们需要做两件事情：

（1）将上界属性limit设置为当前位置    （2）将位置position设置为0

这两步操作，JDK API给开发者提供了一个filp()方法来完成，flip()方法将一个能够继续添加数据元素的填充状态的缓冲区翻转成一个准备读出元素的释放状态，因此每次准备读出元素前，都必须调用一次filp()方法

4、第41行~第48行，每次先判断一下是否已经达到缓冲区的上界，若存在则调用get()方法获取到此元素，get()方法会自动移动下标position

5、第57行，对Buffer的操作完成之后，调用clear()方法将所有属性回归原位，但是clear()方法并不会改变缓冲区中的任何数据

 

缓冲区比较

缓冲区的比较即equals方法，缓冲区的比较并不像我们想像得这么简单，两个缓冲区里面的元素一样就是相等，两个缓冲区相等必须满足以下三个条件：

1、两个对象类型相同，包含不同数据类型的buffer永远不会像等，而且buffer绝不会等于非buffer对象

2、两个对象都剩余相同数量的元素，Buffer的容量不需要相同，而且缓冲区中剩余数据的索引也不必相同。但每个缓冲区中剩余元素的数目（从position到limit）必须相同

3、在每个缓冲区中应被get()函数返回的剩余数据元素序列必须一致

如果不满足上面三个条件，则返回false。下面两幅图演示了两个缓冲区相等和不相等的场景，首先是两个属性不同的缓冲区也可以相等：

然后是两个属性相同但是被等为不相等的缓冲区：

 

字节缓冲区

字节缓冲区和其他缓冲区类型最明显的不同在于，它们可能成为通道所执行I/O的源头或目标，如果对NIO有了解的朋友们一定知道，通道只接收ByteBuffer作为参数。

如我们所知道的，操作系统在内存区域进行I/O操作，这些内存区域，就操作系统方面而言，是相连的字节序列。于是，毫无疑问，只有字节缓冲区有资格参与I/O操作。也请回想一下操作系统会直接存取进程----在本例中是JVM进程的内存空间，以传输数据。这也意味着I/O操作的目标内存区域必须是连续的字节序列，在JVM中，字节数组可能不会在内存中连续存储，或者无用存储单元收集可能随时对其进行移动。在Java中，数组是对象，而数据存储在对象中的方式在不同的JVM实现中各有不同。

出于这一原因，引入了直接缓冲区的概念。直接缓冲区被用于与通道和固有I/O线程交互，它们通过使用固有代码来告知操作系统直接释放或填充内存区域，对用于通道直接或原始存取的内存区域中的字节元素的存储尽了最大的努力。

直接字节缓冲区通常是I/O操作最好的选择。在设计方面，它们支持JVM可用的最高效I/O机制，非直接字节缓冲区可以被传递给通道，但是这样可能导致性能损耗，通常非直接缓冲不可能成为一个本地I/O操作的目标，如果开发者向一个通道中传递一个非直接ByteBuffer对象用于写入，通道可能会在每次调用中隐含地进行下面的操作：

1、创建一个临时的直接ByteBuffer对象

2、将非直接缓冲区的内容复制到临时缓冲中

3、使用临时缓冲区执行低层次I/O操作

4、临时缓冲区对象离开作用于，并最终成为被回收的无用数据

这可能导致缓冲区在每个I/O上复制并产生大量对象，而这种事都是我们极力避免的。

直接缓冲区是I/O的最佳选择，但可能比创建非直接缓冲区要花费更高的成本。直接缓冲区使用的内存是通过调用本地操作系统的代码分配的，绕过了标准JVM堆栈。建立和销毁直接缓冲区会明显比具有堆栈的缓冲区更极爱破费，这取决于主操作系统以及JVM实现。直接缓冲区的内存区域不受无用存储单元收集支配，因为它们位于标准JVM堆栈之外。

直接ByteBuffer是通过调用具有所需容量的ByteBuffer.allocateDirect()函数产生的：

public abstract class ByteBuffer
    extends Buffer
    implements Comparable<ByteBuffer>
{
    ...
    public static ByteBuffer allocateDirect(int capacity)
    {
        return new DirectByteBuffer(capacity);
    }
    ...
}

 

缓冲区Buffer的内部原理

我们说缓冲区对象本质上是一个数组，但它其实是一个特殊的数组，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，如果我们使用get()方法从缓冲区获取数据或者使用put()方法把数据写入缓冲区，都会引起缓冲区状态的变化。

在缓冲区中，最重要的属性有下面三个，它们一起合作完成对缓冲区内部状态的变化跟踪：

position

指定了下一个将要被写入或者读取的元素索引。在从Channel读取数据到Buffer时，position变量用来跟踪截止目前为止从Channel中读出了多少数据，在从Buffer中向Channel写数据时，position变量用来跟踪截止目前为止向Channel写入了多少数据。

limit

在从Channel中读取数据到Buffer中时，limit变量指示了还剩多少空间可供存放数据，在从Buffer向Channel写数据时，limit变量指示了还剩多少数据可以写入。position正常情况下小于或者等于limit。

capacity

指示Buffer最多能够存储的数据。实际上，它指示了底层array的容量，或者至少是底层array允许使用的空间数量。Limit永远不会大于capacity。

接下来我们将逐一检查每个细节，并且也看看为什么这样的设计适合典型的读/写（输入/输出）处理。我们假设从一个Channel拷贝数据到另一个Channel。

首先新建一个容量大小为10的ByteBuffer对象，在初始化的时候，position设置为0，如果我们读一些数据到缓冲区中，那么下一个读取的数据就进入索引为0的字节。如果我们从缓冲区写一些数据，从缓冲区读取的下一个字节就来自索引为0的字节。limit和 capacity被设置为10，在以后使用ByteBuffer对象过程中，capacity的值不会再发生变化，而其它两个将会随着使用而变化。

 

现在我们可以从读通道中读取一些数据到缓冲区中。如果读取到4个字节数据，则此时position的值为4，即下一个将要被写入的字节索引为4，而limit仍然是10，如下图所示：

下一步把读取到的数据写入到写通道中，在此之前必须调用flip()方法，该方法将会完成两件事情：

1. 把limit设置为当前的position值

2. 把position设置为0

position 被设置为 0，这意味着我们得到的下一个字节是第一个字节。limit 已被设置为原来的 position，这意味着它包括以前读到的所有字节，并且一个字节也不多，如下图所示：

我们现在可以将数据从缓冲区写入通道了，这会导致position的增加而limit保持不变，但position不会超过limit的值，所以在读取我们之前写入到缓冲区中的4个字节之后，position和limit的值都为4，如下图所示：

在数据写入到写通道完毕后，调用clear()方法能够把所有的状态变化设置为初始化时的值，该方法将会完成两件事情：

1. 把limit设置为capacity值

2. 把position设置为0

clear()方法会重置Buffer以便接收更多的字节，如下图所示：

 

flip方法

在api中，反转次缓冲区。把limit设置为position，把position设为0，如果定义了标记，则丢弃该标记。

其实这个方法就是只是为了通道或者缓冲区读取到正确的数据。

比如在服务端

ByteBuffer bb = ByteBuffer.allocate(100);
sc.read(bb);
bb.flip();
while (bb.hasRemaining()) {
   System.out.print((char) bb.get());
}

 

客户端

ByteBuffer bb = ByteBuffer.allocate(100);
bb.put("hello".getBytes());
bb.flip();
sc.write(bb);

 

对于客户端来说，执行完put操作后此时的position位置是5，指向数组第六个位置，limit在数组最后，如果此时调用write方法，write方法会取position到limit的数据，此时都是空。

对于服务端来说read后，缓冲区中position位置也是5，limit也是在最后。while判断肯定为true，但是position到limit的部分还是为空，最后肯定也是空值。