一 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