一 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 指针相关方法：

2.1.4 读写相关的方法

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