JavaNIO（八）ByteBuffer和ByteBuf解析

一 ByteBuffer

1.1 ByteBuffer的内部结构和读写模式

Java nio包提供的原生的缓存区类，基本的使用方式是：

• 创建对象，往里面写数据
• 调用flip()方法，转换为读模式
• 从中读取之前写入的数据
• 调用clear() 或者 compact() 清除数据

    public static void main(String[] args) {
        ByteBuffer byteBuffer = ByteBuffer.allocate(20);

        byteBuffer.put(((byte) 1));
        byteBuffer.put(((byte) 2));

        byteBuffer.flip();

        System.out.println(byteBuffer.get());
        System.out.println(byteBuffer.get());

        byteBuffer.clear();
    }

这个类中有三个关键的字段：

• capacity: 容量，即上限，最多能容纳多少数据，对于上面的例子，capacity=20
• limit: 表示最多能读取或者写入多少数据，写模式下，这个值等于capacity；读模型下，这个值为Buffer中保存的数量的长度
• position: 当前的位置，表示下一个读取或者写入数据的位置

这个类中还有四个关键的方法：

• flip(): 从写模型转换成读模式（创建对象后默认为写模式）
• clear(): 清除所有数据，并转换成写模式
• compact(): 清除已经读过的数据，并把未读过的数据全部左移到最左边，然后设置成写模式
• rewind(): 这个方法会把position重置为0，这样的话，如果是写模式，那么后续写入的数据又会从头开始，从而把原来的数据覆盖。如果是读模式，那么后续又可以重新读一遍。

例如上面的例子：

• 刚创建完对象后：capacity=20, limit=20, position=0
• byteBuffer.put(((byte) 1))后: capacity=20, limit=20, position=1
• byteBuffer.put(((byte) 2))后: capacity=20, limit=20, position=2
• byteBuffer.flip()后: capacity=20, limit=2, position=0
• byteBuffer.get()后: capacity=20, limit=2, position=1
• byteBuffer.get()后: capacity=20, limit=2, position=2
• byteBuffer.clear()后: capacity=20, limit=20, position=0

再写个例子，专门说一下compact方法：

        ByteBuffer byteBuffer = ByteBuffer.allocate(4);
        byteBuffer.put(((byte) 1));
        byteBuffer.put(((byte) 2));
        byteBuffer.flip();

        byteBuffer.get();
        System.out.println(byteBuffer);
        byteBuffer.compact();
        System.out.println(byteBuffer);

两次输出的结果：

java.nio.HeapByteBuffer[pos=1 lim=2 cap=4]
java.nio.HeapByteBuffer[pos=1 lim=4 cap=4]

compact前后的内部结构为：

compact前后对比

注意：compact前为读模式，compact后为写模式

1.2 两种ByteBuffer对象

创建ByteBuffer时，有两种方法：

        ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(4);
        ByteBuffer heapByteBuffer = ByteBuffer.allocate(5);

• allocateDirect方法会使用DirectByteBuffer类，使用的是堆外内存。
• allocate方法使用的是HeapByteBuffer类，使用的是堆内存。

二 ByteBuf

Java nio包中的ByteBuffer有以下几个缺点：

• 读写共用一个指针position，所以需要不断的使用flip，rewind，compact等方法来切换读写模式，关键是，如果我们忘记了切换读写模式，尽然也不会抛出异常，从而导致一些奇奇怪怪的问题。
• 不支持扩容，容量初始化的时候就定了，长度不够时不能扩容。

Netty提供的ByteBuf解决了这两个问题：

• 使用了两个指针，readIndex和writeIndex，所有不需要切换读写。
• 支持扩容，每次put数据时都会先检测容量，不足时会扩容。

2.1 ByteBuf的核心字段和方法

2.1.1 核心字段

• writerIndex：下一个即将写入数据的位置
• readerIndex：下一个即将读取的数据的位置
• array: byte数组，保存数据
• capacity: 实际上没有这个字段，但是有这个概念，capacity=array.length
• maxCapacity: 最大可扩容到的容量，默认为Integer.MAX_VALUE，创建对象时可以指定。

2.1.2 创建对象相关的方法

Netty 中使用ByteBufAllocator来创建ByteBuf对象，ByteBufAllocator有两个实现类：PooledByteBufAllocator和UnpooledByteBufAllocator

可以分别有这两个类中的方法，如newDirectBuffer，newHeapBuffer等创建ByteBuf对象。

Netty还把UnpooledByteBufAllocator进一步封装成了Unpooled类，使用这个类的静态方法创建ByteBuf对象更加方便

2.1.3 指针相关方法：

方法名	作用
setIndex(int rIndex, int wIndex)	同时设置readerIndex和writerIndex
writerIndex(int writerIndex)	设置写指针位置
readerIndex(int readerIndex)	设置读指针位置
markReaderIndex()	记录当前的readerIndex位置
resetReaderIndex()	把readerIndex重置为markReaderIndex时的位置

2.1.4 读写相关的方法

方法名	作用
capacity(int nc)	把容量扩容或缩容为新的容量nc即newCapacity
clear()	把readerIndex和writerIndex都置为0
discardReadBytes()	删除已读的数据，这个方法会把0 ~ readerIndex的数据删除，然后把rederIndex~writeIndex的数据往前移，然后把readerIndex和writerIndex的值都减去移除数据的长度。

2.2 实例

    public static void main(String[] args) {
        ByteBuf byteBuf = Unpooled.buffer(10);
        printByteBuf("刚创建对象后", byteBuf);
        byteBuf.writeBytes(new byte[]{1, 2, 3, 4, 5});
        printByteBuf("写入5个数据后", byteBuf);

        byteBuf.readByte();
        byteBuf.readByte();

        printByteBuf("读取两个数据后", byteBuf);

        byteBuf.discardReadBytes();
        printByteBuf("discardReadBytes后", byteBuf);
    }

    private static void printByteBuf(String preMsg, ByteBuf byteBuf) {
        System.out.println(preMsg + ":" + Arrays.toString(byteBuf.array()) + ", rdix=" + byteBuf.readerIndex() + ", wtix=" + byteBuf.writerIndex());
    }

刚创建对象后:[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], rdix=0, wtix=0
写入5个数据后:[1, 2, 3, 4, 5, 0, 0, 0, 0, 0], rdix=0, wtix=5
读取两个数据后:[1, 2, 3, 4, 5, 0, 0, 0, 0, 0], rdix=2, wtix=5
discardReadBytes后:[3, 4, 5, 4, 5, 0, 0, 0, 0, 0], rdix=0, wtix=3

2.3 扩容

2.3.1 何时扩容

在写数据时，会校验ByteBuf的长度，判断ByteBuf中空闲区域的容量是否能容纳新写入的数据，不能时，则需要扩容：

    @Override
    public ByteBuf writeBytes(byte[] src, int srcIndex, int length) {
        ensureWritable(length);
        setBytes(writerIndex, src, srcIndex, length);
        writerIndex += length;
        return this;
    }

2.3.2 扩容长度计算方式

假设写完数据后ByteBuf中数据的总长度是minNewCapacity，则扩容后的容量必需达到或超过这个值。逻辑如下：

• 如果minNewCapacity大于4M，则新长度取比minNewCapacity大的最小4M的整倍数（例如minNewCapacity=3.9M 则新长度取4M，如果minNewCapacity=4.1M 则新长度取8M）
• 如果minNewCapacity大于64字节，则翻倍
• 如果minNewCapacity小于64字节，则直接取64字节

代码如下：

    @Override
    public int calculateNewCapacity(int minNewCapacity, int maxCapacity) {
        final int threshold = CALCULATE_THRESHOLD; // 4 MiB page
        //如果刚好等于4Mib，则直接取4Mib
        if (minNewCapacity == threshold) {
            return threshold;
        }

        // If over threshold, do not double but just increase by threshold.
        //如果大于4Mib，则取比minNewCapacity大的最小4Mib整倍数
        if (minNewCapacity > threshold) {
            //minNewCapacity / threshold * threshold其实是计算比minNewCapacity小的最大threshold整倍数
            int newCapacity = minNewCapacity / threshold * threshold;
            if (newCapacity > maxCapacity - threshold) {
                newCapacity = maxCapacity;
            } else {
                newCapacity += threshold;
            }
            return newCapacity;
        }

        // Not over threshold. Double up to 4 MiB, starting from 64.
        int newCapacity = 64;
        while (newCapacity < minNewCapacity) {
            newCapacity <<= 1;
        }

        return Math.min(newCapacity, maxCapacity);
    }

注意：minNewCapacity / threshold * threshold，是计算比minNewCapacity小的最大threshold整倍数。例如 9 / 2 * 2 = 8