2024-04-04  阅读(37)
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://www.skjava.com/mianshi/baodian/detail/7595430119

回答

ByteBuf是Netty 数据传输的载体,是字节缓冲区,用于在 I/O 操作中存储字节数据。在 Netty 中,数据的读写都是以 ByteBuf 为单位进行交互的。

它与 Java NIO 中的 ByteBuffer 存在以下几个区别:

  • 读写索引
    • ByteBuf:提供了两个独立的索引 —— 一个用于读操作的 readerIndex,另一个用于写操作 writerIndex。这使得 ByteBuf 同时进行读写操作变得更加方便,无需在读和写模式之间切换。
    • ByteBuffer:只有一个位置指针,用于读写操作。在进行读写操作切换时需要调用 flip() ,这使得 ByteBuffer 使用起来不如 ByteBuf 灵活。
  • 引用计数
    • ByteBuf:支持引用计数,这是的 ByteBuf 可以更加有效地管理和回收内存。Netty 可以根据引用计数来判断一个 ByteBuf 是否不再被使用,当引用计数为 0 时,它可以被自动释放,这有助于防止内存泄露。
    • ByteBuffer:不支持引用计数,内存管理完全由 JVM 的垃圾回收器负责,这可能会导致内存泄露。
  • 可扩展性和池化
    • ByteBuf:可以根据需要动态调整容量,更加灵活,同时 Netty 还提供了字节缓冲区池,可以重用 ByteBuf 实例,降低内存分配和回收的开销。
    • ByteBuffer:一旦创建,其容量就固定了,不能动态扩展或缩小,而且它不支持池化,在内存使用方面不及 ByteBuf
  • API的用户友好性
    • ByteBuf:提供了更加丰富和友好的 API,使得对其的操作更加容易和直观。
    • ByteBuffer:其 API 相对较为简单和有限,某些操作可能需要更复杂的步骤和更多的代码。

扩展

ByteBuf内部结构

我们首先看 ByteBuf 的内部结构:

从 ByteBuf 的内部结构可以看出,它包含有三个指针:

  • readerIndex:读指针
  • writerIndex:写指针
  • maxCapacity:最大容量

三个指针将整个 ByteBuf 分为四个部分:

  1. 废弃字节:表示已经丢弃的无效字节,我们可以调用 discardReadBytes() 释放这部分空间。
  2. 可读字节:表示可以从 ByteBuf 中读取到的数据,这部分内容等于 writerIndex - readerIndex。readerIndex 随着我们读取 ByteBuf 中的数据而递增,当从 ByteBuf 中读取 N 个字节, readerIndex 就会自增 N,直到 readerIndex = writerIndex 时,就表示 ByteBuf 不可读。
  3. 可写字节:表示可以向 ByteBuf 可写入的字节。writerIndex 也是随着我们向 ByteBuf 中写入数据而自增,当想 ByteBuf 中写入 N 个字节,writerIndex 就会自增 N,当 writerIndex 超过 capacity 时,就需要扩容了。
  4. 可扩容字节:表示 ByteBuf 最多可扩容多少字节 。当向 ByteBuf 写入的数据超过了 capacity 时,就会触发扩容,但是最多可扩容到 maxCapacity ,超过时就会报错。

从这里就可以看出,ByteBuf 很好地解决了原生 NIO ByteBuffer 的不可扩容及读写模式切换的问题。Netty 为什么要设计两个指针呢?主要是为了能够更加高效、更加灵活地处理数据,有两个指针有如下几个优势:

  1. 读写分离:使用两个指针可以将读写两个操作进行有效地分离,而不会相互影响。这使得在同一时间,我们可以在不破坏数据完整性的前提下,进行同时的读取和写入操作。
  2. 更加灵活:两个指针意味着互相独立,我们可以在不影响读指针的情况下,自由地移动写指针,或者在不影响写指针的情况下,自由地移动读指针,这种分离的设计为数据处理提哦乖乖女了更大的灵活性。

ByteBuf 索引变化

清楚了 ByteBuf 的内部结构,我们还需要了解它内部索引的变化情况。

  • 初始分配:这个时候 readerIndex = writerIndex = 0

  • 当我们向 ByteBuf 中写入 N 个字节后,readerIndex = 0,writerIndex = N

  • 当我们从 ByteBuf 中读取 M(M < N)个字节后,readerIndex = M,writerIndex = N

  • 当我们继续往 ByteBuf 中写入数据时,writerIndex = capacity 时,就无法再写了,这个时候会触发扩容( X )

  • 对弈失效的那部分,我们可以调用 discardReadBytes() 来释放这部分空间,释放完成后,readerIndex = 0,writerIndex = (N + X ) - M

ByteBuf 分类

Netty 提供的 ByteBuf 有多种实现类,每种都有不同的特性和使用场景,主要分为三种类型:

  1. Pooled 和 Unpooled:池化和非池化;
  2. Heap 和 Direct:堆内存和直接内存;
  3. Safe 和 Unsafe:安全和非安全。
  • Pooled 和 Unpooled

Pooled 就是从预先分配好的内存中取出来,使用完成后又放回 ByteBuf 内存中,等待下一次分配。而 Unpooled 是直接调用系统 API 来申请内存的,使用完成后需要立刻销毁的。

从性能上来说,Pooled 要比 Unpooled 性能好,因为它可以重复利用,不需要每次都创建

  • Heap 和 Direct

Heap 就是在 JVM 堆内分配的,其生命周期受 JVM 管理,我们不需要主动回收他们。而 Direct 则由操作系统管理,使用完成后需要主动释放这部分内存,否则容易造成内存溢出。

  • Safe 和 Unsafe

主要是 Java 底层操作数据的一种安全和非安全的方式。Unsafe 表示每次调用 JDK 的 Unsafe 对象操作物理内存的,而 Safe 则不需要依赖 JDK 的 Unsafe 对象,直接通过数组下标的方式来操作。

6 中类型,可以根据不同类型进行组合,在 Netty 中一共有 8 种:

  1. 池化 + 堆内存:PooledHeapByteBuf
  2. 池化 + 直接内存:PooledDirectByteBuf
  3. 池化 + 堆内存 + 不安全:PooledUnsafeHeapByteBuf
  4. 池化 + 直接内存 + 不安全:PooledUnsafeDirectByteBuf
  5. 非池化 + 堆内存:UnpooledHeapByteBuf
  6. 非池化 + 直接内存:UnpooledDirectByteBuf
  7. 非池化 + 堆内存 + 不安全:UnpooledUnsafeHeapByteBuf
  8. 非池化 + 直接内存 + 不安全:UnpooledUnsafeDirectByteBuf

ByteBuf 核心 API

ByteBuf 的核心 API 分为四类:

  1. 容量相关 API
  2. 指针操作相关 API
  3. 数据读写相关 API
  4. 内存管理相关 API

下面我们依次来了解这些 API。

容量相关 API

容量相关的 API 主要用来获取 ByteBuf 的容量的。

  • capacity()

表示 ByteBuf 占用了多少字节的内存,它包括已放弃 + 可读 + 可写。

  • maxCapacity()

表示 ByteBuf 最大能占用多少字节的内存。当不断向 ByteBuf 中写入数据的时候,如果发现容量不足时(writerIndex 超过 capacity)就会触发扩容,最大可扩容到 maxCapacity,如果超过 maxCapacity 时就会抛出异常。

指针操作相关 API

指针操作相关 API 就是操作读写指针的。

  • readerIndex() & readerIndex(int)

前置返回读指针 readerIndex 的位置,而后者是设置读指针 readerIndex 的位置。

  • writerIndex() & writerIndex(int)

前者返回写指针 writerIndex 的位置,而后者是设置写指针 writerIndex 的位置。

  • markReaderIndex() & resetReaderIndex()

markReaderIndex()用于标注当前 readerIndex 的位置,即把当前 readerIndex 保存起来。而 resetReaderIndex() 则是将当前的 readerIndex 指针恢复到之前保存的位置。

  • markWriterIndex() & resetWriterIndex()

与 readerIndex 的一致。

数据读写相关 API

  • readableBytes() & isReadable()

readableBytes() 表示 ByteBuf 中有多少字节可以读,它的值等于 writerIndex - readerIndex。isReadable() 用于判断 ByteBuf 是否可读,若 readableBytes() 返回的值大于 0 ,则 isReadable() 则为 true。

  • readByte() & writeByte(byte b)

readByte() 是从 ByteBuf 中读取一个字节,则 readerIndex + 1。同理 writeByte(byte b) 是向 ByteBuf 中写入一个字节,相应的 writerIndex + 1。

在 Netty 中,它提供了 8 种基础数据类型的读取和写入 API,如 readInt()readLong()readShort() 等等,这里就不一一阐述了。

  • readBytes(byte[] dst) & writeBytes(byte[] src)

readBytes(byte[] dst) 是将 ByteBuf 里面的数据全部读取到 dst 中,这里 dst 数据的大小通常等于 readableBytes()

writeBytes(byte[] src) 则是将 src 数组里面的内容全部写到 ByteBuf 中。

  • getByte(int) & setByte(int,int)

这两个方法与 readByte() & writeByte(byte b) 方法类似,两者区别在于 readByte() 会改变 readerIndex 的位置,而 getByte(int) 则不会改变 readerIndex 的位置。

内存管理相关 API

  • retain() & release()

ByteBuf 是基于引用计数设计的,它实现了 ReferenceCounted 接口。在默认情况下,我们创建一个 ByteBuf 时,它的计数为 1。

当计数大于 0 ,就说该 ByteBuf 还在被使用,当计数等于 0 的时候,说明该 ByteBuf 不再被其他对象所引用。

我们每调用一个 retain() ,计数就 + 1,每调用一次 release() 计数就 - 1,当计数减到 0 的时候,就会被回收。

  • slice() & duplicate() & copy()

slice()从 ByteBuf 中截取一段从 readerIndex 到 writerIndex 之间的数据,该新的 ByteBuf 的最大容量为原始 ByteBuf 的 readableBytes()。新的 ByteBuf 其底层分配的内存、引用计数与原始的 ByteBuf 共享,这样就会有一个问题:如果我们调用新的 ByteBuf 的 write 系列方法,就会影响到原始的 ByteBuf 的底层数据。

duplicate() 也是从 ByteBuf 中截取一段数据,返回一个新的 ByteBuf,但是它截取的是整个原始的 ByteBuf,与 slice() 一样,duplicate() 返回新的 ByteBuf 其底层分配的内存、引用计数与原始 ByteBuf 共享。

copy() 从原始 ByteBuf 中拷贝所有信息,包括读写指针、底层分配的内存、引用计数等等所有的信息,所以新的 ByteBuf 是一个独立的个体,它与原始的 ByteBuf 不再共享。

在使用这三个方法的时候一定要切记如下点:

  • slice()duplicate() 新的 ByteBuf 与原始的 ByteBuf 内存共享、引用计数共享、读写指针不共享
  • copy() 新的 ByteBuf 与原始 ByteBuf 底层内存、引用计数、读写指针都不共享

这三个方法相比其他的方法稍微有那么点难理解,下面大明哥将会通过示例来详细讲解。

示例

下面大明哥就用一个完整的示例来演示 ByteBuf 的核心 API。

private static void printByteBuf(ByteBuf byteBuf,String action) {
    System.out.println("============== " + action + " ================");
    System.out.println("capacity = " + byteBuf.capacity());
    System.out.println("maxCapacity = " + byteBuf.maxCapacity());
    System.out.println("readerIndex = " + byteBuf.readerIndex());
    System.out.println("writerIndex = " + byteBuf.writerIndex());
    System.out.println("readableBytes = " + byteBuf.readableBytes());
    System.out.println("isWritable = " + byteBuf.isWritable());
    
    System.out.println();
}

先加一个打印 ByteBuf 核心属性的方法,后面都用该方法来查看 ByteBuf 的相关信息

ByteBuf byteBuf = ByteBufAllocator.DEFAULT.buffer(15,20);
printByteBuf(byteBuf,"new buffer(15,20)");   

//===== 执行结果 ======
============== new buffer(15,20) ================
capacity = 15
maxCapacity = 20
readerIndex = 0
writerIndex = 0
readableBytes = 0
isWritable = true

申请一个 capacity = 15 ,maxCapacity = 20 的 ByteBuf ,由于是新申请的,所以 readerIndex = writerIndex = 0,示例图如下:

  • 我们往该 ByteBuf 写入 6 个字节。
// 写入四个字节
byteBuf.writeBytes(new byte[]{1,2,3,4,5,6});
printByteBuf(byteBuf,"写入 6 个字节");

//===== 执行结果 ======
============== 写入 6 个字节 ================
capacity = 15
maxCapacity = 20
readerIndex = 0
writerIndex = 6
readableBytes = 6
isWritable = true

写入四个字节后,writerIndex = 6,可读字节数为 6,示例图如下:

  • 这个时候 ByteBuf 中有 6 个可以读的字节,我们先读取 4 个字节
// 读取 4 个字节
byteBuf.readInt();
printByteBuf(byteBuf,"读取 4 个字节");

//===== 执行结果 ======
============== 读取 4 个字节 ================
capacity = 15
maxCapacity = 20
readerIndex = 4
writerIndex = 6
readableBytes = 2
isWritable = true

读取 4 个字节后,readerIndex = 4,writerIndex = 6,可读字节数 readableBytes = 2,示例图如下:

  • 如果我们继续读取两个字段
// 读取两个字节
byteBuf.readBytes(new byte[2]);
printByteBuf(byteBuf,"读取 2 个字节");

//===== 执行结果 ======
============== 读取 2 个字节 ================
capacity = 15
maxCapacity = 20
readerIndex = 6
writerIndex = 6
readableBytes = 0
isWritable = true

这个时候你会发现 readableBytes = 0 ,那么 isReadable() 就为 false,意味着该 ByteBuf 当前不可读,此时 readerIndex = writerIndex = 6,示例图如下:

  • 我们再往该 ByteBuf 中写入 8 个字节
// 写入 8 个字节
byteBuf.writeBytes(new byte[]{7,8,9,10,11,12,13,14});
printByteBuf(byteBuf,"写入 8 个字节");

// getXx 获取 ByteBuf 中的值
System.out.println("getByte(3) = " + byteBuf.getByte(3));
printByteBuf(byteBuf,"getByte(3)");

// setBytes
byteBuf.setByte(8,1);
printByteBuf(byteBuf,"setByte(8,1)");

//===== 执行结果 ======
============== 写入 8 个字节 ================
capacity = 15
maxCapacity = 20
readerIndex = 6
writerIndex = 14
readableBytes = 8
isWritable = true

getByte(3) = 4
============== getByte(3) ================
capacity = 15
maxCapacity = 20
readerIndex = 6
writerIndex = 14
readableBytes = 8
isWritable = true

============== setByte(8,1) ================
capacity = 15
maxCapacity = 20
readerIndex = 6
writerIndex = 14
readableBytes = 8
isWritable = true   

到这里我们发现 getXxx()setXxx() 不会改变 readerIndex 和 writerIndex 的位置。示例图如下:

  • 下面我们再使用 slice()duplicate()copy() 三个拷贝方法来演示下
// slice
ByteBuf sliceByte = byteBuf.slice();
printByteBuf(sliceByte,"sliceByte");

// duplicateByte
ByteBuf duplicateByte = byteBuf.duplicate();
printByteBuf(duplicateByte,"duplicateByte");

//===== 执行结果 ======
============== sliceByte ================
capacity = 8
maxCapacity = 8
readerIndex = 0
writerIndex = 8
readableBytes = 8
isWritable = false

============== duplicateByte ================
capacity = 15
maxCapacity = 20
readerIndex = 6
writerIndex = 14
readableBytes = 8
isWritable = true

从执行结果可以看出,slice() 截取的是原始 ByteBuf 的 readerIndex 到 writerIndex 的部分,其中 capacity = maxCapacity = writerIndex = writerIndex - readerIndex ,这也就预示着该 ByteBuf 不可读。而 duplicate() 则是截取的整个原始 ByteBuf 的信息。

现在我们对这两个 ByteBuf 做一番操作。

// 读取 sliceByte
sliceByte.readInt();
printByteBuf(sliceByte,"sliceByte.readInt()");

// 读取
duplicateByte.readInt();
printByteBuf(duplicateByte,"duplicateByte.readInt()");

// 读取后原始 ByteBuf
printByteBuf(byteBuf,"读取后,原始 ByteBuf");

//===== 执行结果 ======
============== sliceByte.readInt() ================
capacity = 8
maxCapacity = 8
readerIndex = 4
writerIndex = 8
readableBytes = 4
isWritable = false

============== duplicateByte.readInt() ================
capacity = 15
maxCapacity = 20
readerIndex = 10
writerIndex = 14
readableBytes = 4
isWritable = true

============== 读取后,原始 ByteBuf ================
capacity = 15
maxCapacity = 20
readerIndex = 6
writerIndex = 14
readableBytes = 8
isWritable = true

从运行结果我们知道对 slice()duplicateByte() 进行读操作后,完全不会影响原始的 ByteBuf,那写呢?

// 写 duplicateByte
duplicateByte.writeBytes(new byte[]{1});
printByteBuf(duplicateByte,"duplicateByte.writeByte(0)");

// 写后原始 ByteBuf
printByteBuf(byteBuf,"写后,原始 ByteBuf");

System.out.println("setByte(8,123) 之前,duplicateByte = " + duplicateByte.getByte(8));
System.out.println("setByte(8,123) 之前,byteBuf = " + byteBuf.getByte(8));

duplicateByte.setByte(8,123);
System.out.println("setByte(8,123) 之后,duplicateByte = " + duplicateByte.getByte(8));
System.out.println("setByte(8,123) 之后,byteBuf = " + byteBuf.getByte(8));

//===== 执行结果 ======
============== duplicateByte.writeByte(0) ================
capacity = 15
maxCapacity = 20
readerIndex = 10
writerIndex = 15
readableBytes = 5
isWritable = false

============== 写后,原始 ByteBuf ================
capacity = 15
maxCapacity = 20
readerIndex = 6
writerIndex = 14
readableBytes = 8
isWritable = true

setByte(8,123) 之前,duplicateByte = 1
setByte(8,123) 之前,byteBuf = 1
setByte(8,123) 之后,duplicateByte = 123
setByte(8,123) 之后,byteBuf = 123

仔细观察运行结果,发现 duplicateByte.writeBytes() 之后,原始 ByteBuf 的结构其实并没有发生变化,他的 readerIndex 依旧 = 6,writerIndex = 14。但是 duplicateByte.setByte(8,123) 之后,原始 ByteBuf 的值发生了变化,这就是我在前面提到过的:**使用 **slice()duplicate() 生成出来的新 ByteBuf 与原生 ByteBuf 是共享底层数据和引用计数,但是不共享读写指针的。这点在使用过程中要格外注意。

  • 我们继续往 ByteBuf 里面写入数据
// 继续写 2 个字节
byteBuf.writeBytes(new byte[]{15,16});
printByteBuf(byteBuf,"写 2 个字节后");

// 再写 1 个
byteBuf.writeBytes(new byte[]{17});
printByteBuf(byteBuf,"写 1 个字节后");

//===== 执行结果 ======
============== 写 2 个字节后 ================
capacity = 16
maxCapacity = 20
readerIndex = 6
writerIndex = 16
readableBytes = 10
isWritable = false

============== 写 1 个字节后 ================
capacity = 20
maxCapacity = 20
readerIndex = 6
writerIndex = 17
readableBytes = 11
isWritable = true

当我们写入两个字节后,isWritable = false 说明该 ByteBuf 已经满容量了,不可写了,我们再写入后就触发了扩容,这个时候 capacity = maxCapacity = 20。示例图如下:

如果这个时候我们再往里面写 5 个字节就会报错,抛出异常:

java.lang.IndexOutOfBoundsException: writerIndex(17) + minWritableBytes(5) exceeds maxCapacity(20): PooledUnsafeDirectByteBuf(ridx: 6, widx: 17, cap: 20/20)
  • 在讲述 ByteBuf 的原理的时候,大明哥说过,对于已废弃的内容,我们可以使用 discardReadBytes() 来释放这部分空间。
byteBuf.discardReadBytes();
printByteBuf(byteBuf,"discardReadBytes 之后");

//===== 执行结果 ======
============== discardReadBytes 之后 ================
capacity = 20
maxCapacity = 20
readerIndex = 0
writerIndex = 11
readableBytes = 11
isWritable = true

释放已废弃内存空间后,ByteBuf 的 readerIndex = 0,writerIndex = writerIndex - readerIndex。示意图如下:

阅读全文
  • 点赞