Buffer的使用

Buffer的实现如下图所示：
Alt text 使用的最多的是ByteBuffer，其他的实现类和ByteBuffer使用和API大致相同。

1. Buffer的常见API

1.1 allocate()

获得一个Buffer对象首先要进行分配内存大小, allocate()方法可以指定Buffer的大小。如果是ByteBuffer分配后返回的对象是HeapByteBuffer对象。

java

// 分配48字节capacity的ByteBuffer
ByteBuffer buf = ByteBuffer.allocate(48);   
// 分配一个可存储1024个字符的CharBuffer
CharBuffer buf = CharBuffer.allocate(1024);

Buffer一经创建大小不可更改，但是NIO框架Netty中的Buffer做了增强，可以动态修改缓冲区大小。

1.2 allocateDirect()

从操作系统申请分配内存, allocateDirect()方法可以指定Buffer的大小。如果是ByteBuffer分配后返回的对象是DirectByteBuffer对象，并且默认获取字节顺序为BIG_ENDIAN。

java

ByteBuffer buffer1 = ByteBuffer.allocateDirect(10);

1.3 wrap()

将一个byte[]包装成ByteBuffer对象, 默认获取字节顺序为BIG_ENDIAN。

1.4 put()

在写模式下，向Buffer中写数据，支持单个和多个数据写入。

java

ByteBuffer buffer1 = ByteBuffer.allocate(10);
buffer1.put((byte) 12);
buffer1.put(new byte[]{4,1,5});

1.5 get()

在读模式下，向Buffer中获取指定位置的数据，支持读取单个和多个数据。

1.6 flip()

flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，limit值设置成之前position的值。

1.7 clear()

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

1.8 compact()

如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素后面。limit属性依然像clear()方法一样，设置成capacity。

1.9 rewind()

rewind()将position设回0，用来在读模式下重复读Buffer中的所有数据。

java

public static void main(String[] args) {
    byte[] array = {23, 56, 78};
    ByteBuffer buffer = ByteBuffer.wrap(array);
    byte[] b = new byte[array.length];
    // 一次性读完
    buffer.get(b);
    // 从头开始读
    buffer.rewind();
}

1.10 mark()

在缓冲区操作过程当中，可以将当前的position值临时存入mark属性中；需要的时候，再从mark中取出暂存的标记值，恢复到position属性中，重新从position位置开始处理。

1.11 reset()

配合mark()方法使用, 通过调用reset()方法恢复到mark()标记的position。

java

public static void main(String[] args) {
    byte[] array = {23, 56, 78};
    ByteBuffer buffer = ByteBuffer.wrap(array);
    buffer.get();
    buffer.mark();// 读到索引1的位置
    buffer.get();
    buffer.get();
    // 回到之前mark的位置
    buffer.reset();
    System.out.println(buffer.position());
}

2. 字符串与ByteBuffer互转

2.1 字符串转ByteBuffer

java

// 方法1 使用put()，转成的ByteBuffer处于写模式
ByteBuffer buffer1 = ByteBuffer.allocate(10);
buffer.put("hello".getBytes(StandardCharsets.UTF_8));
// 方法2，使用encode()，转成的ByteBuffer处于读模式
ByteBuffer buffer2 = StandardCharsets.UTF_8.encode("你好");
ByteBuffer buffer3 = Charset.forName("utf-8").encode("你好");
// 方法3，使用warp(), 转成的ByteBuffer处于读模式
ByteBuffer buffer4 = ByteBuffer.wrap("hello nio".getBytes(StandardCharsets.UTF_8));

2.2 ByteBuffer转字符串

java

// 方法1，使用get()
byte[] bytes = new byte[10];
buffer1.flip();
// 如果是直接缓冲区，需要在while中循环读取
buffer1.get(bytes);
String str1 = new String(bytes, StandardCharsets.UTF_8);
// 方法2，使用decode()
String str2 = StandardCharsets.UTF_8.decode(buffer1).toString();

3. 分散读(Scattering Reads)

从Channel中读取是指在读操作时将读取的数据写入多个buffer中。因此Channel将从Channel中读取的数据"分散(scatter)"到多个Buffer中。如下图描述： Alt text

java

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);

ByteBuffer[] bufferArray = { header, body };
channel.read(bufferArray);

read()方法按照buffer在数组中的顺序将从channel中读取的数据写入到buffer，当一个buffer被写满后，channel紧接着向另一个 buffer中写。意味着如果存在消息头和消息体，消息头必须完成填充(例如128byte)，Scattering Reads才能正常工作。

4. 聚合写(Gathering Writes)

写入Channel是指在写操作时将多个buffer的数据写入同一个Channel，因此Channel将多个Buffer中的数据"聚集(gather)"后发送到Channel。如下图描述： Alt text

java

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
ByteBuffer[] bufferArray = { header, body };
channel.write(bufferArray);

buffers数组是write()方法的入参，write()方法会按照buffer在数组中的顺序，将数据写入到channel，注意只有position和limit之间的数据才会被写入。因此如果一个buffer的容量为128byte，但是仅仅包含58byte的数据，那么这58byte的数据将被写入到channel中。因此与Scattering Reads相反Gathering Writes能较好的处理动态消息。

5. Buffer分片

可以根据现有的Buffer(缓冲区对象）来创建一个子缓冲区，即在现有缓冲区上切出一片来作为一个新的缓冲区，但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的，也就是说，子缓冲区相当于是现有缓冲区的一个视图窗口。调用 slice()方法可以创建一个子缓冲区。

java

@Test
public void testSlice() throws IOException {
    ByteBuffer buffer = ByteBuffer.allocate(10);
    // 缓冲区中的数据 0-9
    for (int i = 0; i < buffer.capacity(); ++i) {
        buffer.put((byte) i);
    }
    // 创建子缓冲区
    buffer.position(3);
    buffer.limit(7);
    ByteBuffer slice = buffer.slice();

    // 改变子缓冲区的内容
    for (int i = 0; i < slice.capacity(); ++i) {
        byte b = slice.get(i);
        b *= 10;
        slice.put(i, b);
    }
    buffer.position(0);
    buffer.limit(buffer.capacity());
    while (buffer.remaining() > 0) {
        System.out.println(buffer.get());
    }
}

运行结果：
Alt text

6. 只读缓冲区

只读缓冲区可以读取它们，但是不能向它们写入数据。通过调用缓冲区的asReadOnlyBuffer()方法，将任何常规缓冲区转换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区，并与原缓冲区共享数据，只不过它是只读的。如果原缓冲区的内容发生了变化，只读缓冲区的内容也随之发生变化。

java

@Test
public void testReadOnly() {
    ByteBuffer buffer = ByteBuffer.allocate(10);
    // 缓冲区中的数据0-9
    for (int i = 0; i < buffer.capacity(); ++i) {
        buffer.put((byte) i);
    }
    // 创建只读缓冲区
    ByteBuffer readonly = buffer.asReadOnlyBuffer();
    // 改变原缓冲区的内容
    for (int i = 0; i < buffer.capacity(); ++i) {
        byte b = buffer.get(i);
        b *= 10;
        buffer.put(i, b);
    }
    readonly.position(0);
    readonly.limit(buffer.capacity());
    // 只读缓冲区的内容也随之改变
    while (readonly.remaining() > 0) {
        System.out.println(readonly.get());
    }
}

如果尝试修改只读缓冲区的内容，则会报ReadOnlyBufferException异常。

7. 直接缓冲区

直接缓冲区是为加快I/O速度，给定一个直接字节缓冲区，Java虚拟机将尽最大努力直接对它执行本机I/O操作。也就是说它会在每一次调用底层操作系统的本机I/O操作之前(或之后)，尝试避免将缓冲区的内容拷贝到一个中间缓冲区中或者从一个中间缓冲区中拷贝数据。要分配直接缓冲区。拷贝文件示例:

java

@Test
public void testFastBuffer() throws IOException {
    String infile = "d:\\jack\\01.txt";
    FileInputStream fin = new FileInputStream(infile);
    FileChannel fcin = fin.getChannel();
    String outfile = String.format("d:\\jack\\02.txt");
    FileOutputStream fout = new FileOutputStream(outfile);
    FileChannel fcout = fout.getChannel();
    // 使用 allocateDirect，而不是 allocate
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
    while (true) {
        buffer.clear();
        int r = fcin.read(buffer);
        if (r == -1) {
            break;
        }
        buffer.flip();
        fcout.write(buffer);
    }
}

非直接缓冲区和直接缓冲区区别

特性	非直接缓冲区	直接缓冲区
内存位置	Java堆内存	操作系统物理内存(内核空间)
内存管理	由JVM垃圾回收机制管理	需手动管理，可能调用System.gc()辅助回收
I/O性能	可能存在额外的内存复制开销，性能相对较低	减少了内存复制操作，I/O性能较高
创建和销毁成本	较低	较高，需要与操作系统交互
使用场景	适用于对内存使用较为敏感、数据量较小且I/O操作不频繁的场景	适用于大量数据的频繁I/O操作，如网络编程、文件读写等

7. 内存映射文件I/O

内存映射文件I/O是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的I/O快的多。内存映射文件I/O是通过使文件中的数据出现为内存数组的内容来完成的，只有文件中实际读取或者写入的部分才会映射到内存中。

java

static private final int start = 0;
static private final int size = 1024;
static public void main(String args[]) throws Exception {
    RandomAccessFile raf = new RandomAccessFile("d:\\jack\\01.txt", "rw");
    FileChannel fc = raf.getChannel();
    MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, start, size);
    mbb.put(0, (byte) 97);
    mbb.put(1023, (byte) 122);
    raf.close();
}

Buffer的使用 ​

1. Buffer的常见API ​

1.1 allocate() ​

1.2 allocateDirect() ​

1.3 wrap() ​

1.4 put() ​

1.5 get() ​

1.6 flip() ​

1.7 clear() ​

1.8 compact() ​

1.9 rewind() ​

1.10 mark() ​

1.11 reset() ​

2. 字符串与ByteBuffer互转 ​

2.1 字符串转ByteBuffer ​

2.2 ByteBuffer转字符串 ​

3. 分散读(Scattering Reads) ​

4. 聚合写(Gathering Writes) ​

5. Buffer分片 ​

6. 只读缓冲区 ​

7. 直接缓冲区 ​

7. 内存映射文件I/O ​

Buffer的使用

1. Buffer的常见API

1.1 allocate()

1.2 allocateDirect()

1.3 wrap()

1.4 put()

1.5 get()

1.6 flip()

1.7 clear()

1.8 compact()

1.9 rewind()

1.10 mark()

1.11 reset()

2. 字符串与ByteBuffer互转

2.1 字符串转ByteBuffer

2.2 ByteBuffer转字符串

3. 分散读(Scattering Reads)

4. 聚合写(Gathering Writes)

5. Buffer分片

6. 只读缓冲区

7. 直接缓冲区

7. 内存映射文件I/O