Java NIO之常用缓冲区ByteBuffer详解

定义：ByteBuffer是Buffer的实现类之一，是一个通用的缓冲区，功能要比其他缓冲区子类多。支持直接内存。是一个抽象类。子类实现是HeapByteBuffer（非直接缓冲区子类），DirectByteBuffer（直接缓冲区子类）。看此文前建议看看：关于Buffer可以查看 Java NIO学习篇之缓冲区Buffer详解直接缓冲区：以上是书《深入理解Java虚拟机》对直接内存的描述。简单来

Jeremy_Lee123

1366人浏览 · 2021-02-26 23:33:20

Jeremy_Lee123 · 2021-02-26 23:33:20 发布

一、直接与非直接缓冲区

以上是书《深入理解Java虚拟机》对直接内存的描述。简单来说直接内存不是JVM内存，而是计算机真正的物理内存。但有可能会报错OOM，参考：OOM之Direct buffer memory

mmap（内存映射） 实现对传统文件IO优化，通过把内核缓冲区和用户缓冲区映射在物理内存上映射为同一地址空间。这样就不用对数据进行复制了。数据拷贝次数从4次缩短到了两次。

使用直接缓冲区可以使得内核缓冲区和用户缓冲区映射到同一块物理内存地址上，使得可以省略复制步骤，实现零拷贝，提高效率。

字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，
它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
直接字节缓冲区还可以通过 FileChannel 的 map() 方法将文件区域直接映射到内存中来创建。该方法返回 MappedByteBuffer 。Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。
字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。

Demo测试：

//使用直接缓冲区API进行一个1GB左右的文件进行拷贝
    public static void testDirect(){
        try {
            long start = System.currentTimeMillis();
            FileChannel srcFileChannel = FileChannel.open(Paths.get("J:\\04_JUC&NIO\\zip_bak\\juc.zip"), StandardOpenOption.READ);
            FileChannel destFileChannel = FileChannel.open(Paths.get("J:\\04_JUC&NIO\\zip_bak\\juc_direct.zip"),StandardOpenOption.CREATE,
                    StandardOpenOption.WRITE,StandardOpenOption.READ);
            MappedByteBuffer srcByteBuffer = srcFileChannel.map(FileChannel.MapMode.READ_ONLY,0,srcFileChannel.size());
            MappedByteBuffer descByteBuffer = destFileChannel.map(FileChannel.MapMode.READ_WRITE,0,srcFileChannel.size());
            descByteBuffer.put(srcByteBuffer);
            srcFileChannel.close();
            destFileChannel.close();
            System.out.println("直接缓冲区耗时：" + (System.currentTimeMillis()-start));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void testSimpleIO(){
        try {
            long start = System.currentTimeMillis();
            FileChannel srcFileChannel = FileChannel.open(Paths.get("J:\\04_JUC&NIO\\zip_bak\\juc.zip"), StandardOpenOption.READ);
            FileChannel destFileChannel = FileChannel.open(Paths.get("J:\\04_JUC&NIO\\zip_bak\\juc_simpleIO.zip"),StandardOpenOption.CREATE,
                    StandardOpenOption.WRITE,StandardOpenOption.READ);
            ByteBuffer byteBuffer = ByteBuffer.allocate((int) srcFileChannel.size());
            while (srcFileChannel.read(byteBuffer)!=-1){
                byteBuffer.flip();
                destFileChannel.write(byteBuffer);
                byteBuffer.clear();
            }

            srcFileChannel.close();
            destFileChannel.close();

            System.out.println("非缓冲区耗时：" + (System.currentTimeMillis()-start));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

结果：

二、常用API详解

package com.lxk.nio;

import java.nio.ByteBuffer;

import org.junit.Test;

/*
 * 一、缓冲区（Buffer）：在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
 *
 * 根据数据类型不同（boolean 除外），提供了相应类型的缓冲区：
 * ByteBuffer
 * CharBuffer
 * ShortBuffer
 * IntBuffer
 * LongBuffer
 * FloatBuffer
 * DoubleBuffer
 *
 * 上述缓冲区的管理方式几乎一致，通过 allocate() 获取缓冲区
 *
 * 二、缓冲区存取数据的两个核心方法：
 * put() : 存入数据到缓冲区中
 * get() : 获取缓冲区中的数据
 *
 * 三、缓冲区中的四个核心属性：
 * capacity : 容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
 * limit : 界限，表示缓冲区中可以操作数据的大小。（limit 后数据不能进行读写）
 * position : 位置，表示缓冲区中正在操作数据的位置。
 *
 * mark : 标记，表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置
 *
 * 0 <= mark <= position <= limit <= capacity(固定)
 *
 * 四、直接缓冲区与非直接缓冲区：
 * 非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中
 * 直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率
 */
public class TestBuffer {

    @Test
    public void test0() {
        // 缓冲区建立在 JVM 的内存
        ByteBuffer jvmBuf = ByteBuffer.allocate(1024);
        System.out.println(jvmBuf); // java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]
        System.out.println(jvmBuf.isDirect()); //false
        //分配直接缓冲区
        ByteBuffer directBuf = ByteBuffer.allocateDirect(1024);
        System.out.println(directBuf);  // java.nio.DirectByteBuffer[pos=0 lim=1024 cap=1024]
        System.out.println(directBuf.isDirect()); //true
    }

    @Test
    public void test1() {
        String str = "abcde";

        //1. 分配一个指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);

        System.out.println("-----------------allocate()----------------");
        System.out.println(buf.position()); // 0
        System.out.println(buf.limit()); // 1024
        System.out.println(buf.capacity()); // 1024

        //2. 利用 put() 存入数据到缓冲区中
        buf.put(str.getBytes());

        System.out.println("-----------------put()----------------");
        System.out.println(buf.position());//5
        System.out.println(buf.limit());//1024
        System.out.println(buf.capacity());//1024

        //3. 切换读取数据模式
        buf.flip();

        System.out.println("-----------------flip()----------------");
        System.out.println(buf.position());//0
        System.out.println(buf.limit());//5
        System.out.println(buf.capacity());//1024

        //4. 利用 get() 读取缓冲区中的数据
        byte[] dst = new byte[buf.limit()];
        buf.get(dst);
        System.out.println(new String(dst, 0, dst.length));//abcde

        System.out.println("-----------------get()----------------");
        System.out.println(buf.position());//5
        System.out.println(buf.limit());//5
        System.out.println(buf.capacity());//1024

        //5. rewind() : 可重复读
        buf.rewind();

        System.out.println("-----------------rewind()----------------");
        System.out.println(buf.position());//0
        System.out.println(buf.limit());//5
        System.out.println(buf.capacity());//1024

        //6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
        buf.clear();

        System.out.println("-----------------clear()----------------");
        System.out.println(buf.position());//0
        System.out.println(buf.limit());//1024
        System.out.println(buf.capacity());//1024

        System.out.println((char) buf.get());//a

    }

    @Test
    public void test2() {
        // 0 <= mark <= position <= limit <= capacity
        String str = "abcde";
        ByteBuffer buf = ByteBuffer.allocate(1024);
        buf.put(str.getBytes()); // put--缓存写,反过来读

        System.out.println(buf.mark());// java.nio.HeapByteBuffer[pos=5 lim=1024 cap=1024]
        System.out.println(buf.position());//5 相当于写的标记，类似游标
        System.out.println(buf.limit());//1024
        System.out.println(buf.capacity());//1024
        buf.flip(); // 切换为读模式
        System.out.println(buf.mark());//java.nio.HeapByteBuffer[pos=0 lim=5 cap=1024]
        System.out.println(buf.position());//0
        System.out.println(buf.limit());//5
        System.out.println(buf.capacity());//1024

        byte[] dst = new byte[buf.limit()];
        buf.get(dst, 0, 2); // get--缓存读，反过来读
        System.out.println(new String(dst)); //ab
        System.out.println(new String(dst, 0, 2)); //ab
        System.out.println(buf.position()); // 2

        //mark() : 标记
        buf.mark();

        buf.get(dst, 2, 2); // 再取一次
        System.out.println(new String(dst)); //abcd
        System.out.println(new String(dst, 2, 2)); //cd
        System.out.println(buf.position()); //4

        //reset() : 恢复到 上一次mark 的位置
        buf.reset();
        System.out.println(buf.position()); //2

        //判断缓冲区中是否还有剩余数据
        if (buf.hasRemaining()) {
            //获取缓冲区中可以操作的数量
            System.out.println(buf.remaining()); //3 注意不是1022
        }
    }

    @Test
    public void test3() {
        // 0 <= mark <= position <= limit <= capacity
        String str = "abcde";
        ByteBuffer buf = ByteBuffer.allocate(1024);
        System.out.println(buf);//java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]
        buf.put(str.getBytes()); // put--缓存写,反过来读
        System.out.println(buf);//java.nio.HeapByteBuffer[pos=5 lim=1024 cap=1024]

        buf.put("fg".getBytes()); // 持续写，数据不会清掉
        System.out.println(buf);//java.nio.HeapByteBuffer[pos=7 lim=1024 cap=1024]

        buf.flip(); // 切换读写模式，此处切换为读模式
        System.out.println(buf);//java.nio.HeapByteBuffer[pos=0 lim=7 cap=1024]

        buf.put("hi".getBytes()); // 读模式写数据，数据丢失，且容量同读limit
        System.out.println(buf);//java.nio.HeapByteBuffer[pos=2 lim=7 cap=1024]

        buf.flip(); // 切换读写模式，此处切换为读模式
        System.out.println(buf);//java.nio.HeapByteBuffer[pos=0 lim=2 cap=1024]
        buf.flip(); // 再次切换为写模式--数据情况
        System.out.println(buf);//java.nio.HeapByteBuffer[pos=0 lim=0 cap=1024]
    }
}

其他六种基本类型的缓冲区API与ByteBuffer的子集类似，有些只是多了解码编码，所以，只要学会ByteBuffer的API差不多等于学会了其他六种基本类型的API。

三、源码解析

package java.nio;

public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer>
{
    final byte[] hb;                  // Non-null only for heap buffers
    final int offset;
    boolean isReadOnly;                 // Valid only for heap buffers

    public static ByteBuffer allocate(int capacity) {
        if (capacity < 0)
            throw new IllegalArgumentException();
        return new HeapByteBuffer(capacity, capacity);
    }

    public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
    }


    // 写
    public final ByteBuffer put(byte[] src) {
        return put(src, 0, src.length);
    }

    // 读
    public ByteBuffer get(byte[] dst) {
        return get(dst, 0, dst.length);
    }

    // 切换读模式
    public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

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

  
    // 标志位情况，数据没有真正清空
    public final Buffer clear() {
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
    }
}