❃博主首页 ：

「码到三十五」 ，同名公众号 :「码到三十五」

♝博主的话 ：

搬的每块砖，皆为峰峦之基；公众号搜索「码到三十五」关注这个爱发技术干货的coder，一起筑基

Netty，作为一款高性能的网络编程框架，提供了丰富的字节缓冲区（ByteBuf）实现，以满足不同的内存管理需求。其中，UnpooledHeapByteBuf是Netty提供的一种非池化的堆内存ByteBuf实现。本文将结合源码，深入探讨UnpooledHeapByteBuf的工作原理、实现细节以及其在Netty中的作用。

文章目录
  • 一、UnpooledHeapByteBuf概述
  • 二、工作原理与实现细节
  • 三、源码解析
  • UnpooledHeapByteBuf的使用
  • 1. 创建实例
  • 2. 读写数据
  • 3. 索引管理
  • 4. 容量管理
  • 5. 释放资源
  • 五、使用场景与性能考虑
  • 总结

一、UnpooledHeapByteBuf概述

UnpooledHeapByteBuf是Netty中的一个ByteBuf实现，它表示一个非池化的、存储在JVM堆内存中的字节缓冲区。与池化的ByteBuf（如PooledByteBuf）不同，UnpooledHeapByteBuf在每次需要时都会单独分配和释放内存，不会重用内存块。这使得它在某些场景下可能不如池化的ByteBuf性能高效，但在需要独立控制内存生命周期或避免池化内存管理开销的场景下，UnpooledHeapByteBuf是一个很好的选择。

二、工作原理与实现细节

UnpooledHeapByteBuf的工作原理相对简单，它主要依赖于JVM的堆内存来存储字节数据。以下是其关键实现细节：

  1. 内存分配：
    当需要创建一个UnpooledHeapByteBuf时，Netty会直接在JVM的堆内存中分配一个字节数组来存储数据。这个字节数组的大小由用户在创建UnpooledHeapByteBuf时指定。
  2. 数据访问：
    UnpooledHeapByteBuf提供了丰富的方法来访问和操作存储在字节数组中的数据。例如，用户可以使用readByte()、writeByte()等方法来读取和写入字节数据。
  3. 内存释放：
    由于UnpooledHeapByteBuf是非池化的，因此当它不再需要时，JVM的垃圾回收器会自动回收其占用的堆内存。用户无需手动释放内存。
三、源码解析

以下是UnpooledHeapByteBuf的一些关键源码：

public class UnpooledHeapByteBuf extends AbstractReferenceCountedByteBuf {
    private final byte[] array;
    private int readerIndex;
    private int writerIndex;

    public UnpooledHeapByteBuf(byte[] initialArray, int readerIndex, int writerIndex) {
        // ... 参数校验等 ...
        this.array = initialArray;
        this.readerIndex = readerIndex;
        this.writerIndex = writerIndex;
    }

    @Override
    public byte readByte() {
        checkReadableBytes0(1);
        int i = readerIndex;
        byte b = _getByte(i);
        readerIndex = i + 1;
        return b;
    }

    @Override
    public ByteBuf writeByte(int value) {
        ensureWritable0(1);
        _setByte(writerIndex, value);
        writerIndex++;
        return this;
    }

    // ... 其他方法 ...

    private byte _getByte(int index) {
        return array[index];
    }

    private void _setByte(int index, int value) {
        array[index] = (byte) value;
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.

UnpooledHeapByteBuf继承自AbstractReferenceCountedByteBuf，表示它是一个具有引用计数的ByteBuf实现。它包含一个字节数组array来存储数据，以及readerIndex和writerIndex来分别表示读指针和写指针的位置。

readByte()和writeByte()方法是UnpooledHeapByteBuf提供的用于读取和写入字节数据的示例方法。它们分别通过_getByte()和_setByte()私有方法来访问和修改字节数组中的数据。

UnpooledHeapByteBuf的使用
1. 创建实例

通常，你不需要直接通过构造函数来创建 UnpooledHeapByteBuf 的实例，因为 Netty 提供了更简洁和易于使用的静态工厂方法。最常用的方法是通过 Unpooled 类来创建：

// 创建一个默认容量的 UnpooledHeapByteBuf
ByteBuf buffer = Unpooled.buffer();

// 创建一个指定容量的 UnpooledHeapByteBuf
ByteBuf bufferWithCapacity = Unpooled.buffer(1024); // 容量为1024字节
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.

这些方法内部会调用 UnpooledByteBufAllocator 的相应方法来实例化 UnpooledHeapByteBuf 或其子类（取决于 JVM 是否支持 sun.misc.Unsafe）。

2. 读写数据

UnpooledHeapByteBuf 提供了丰富的读写方法，允许你以不同的方式操作缓冲区中的数据。以下是一些常用的读写方法：

  • 读数据：
byte b = buffer.readByte(); // 读取一个字节
int i = buffer.readInt();   // 读取一个整型（4字节）
// ... 其他读方法
  • 1.
  • 2.
  • 3.
  • 写数据：
buffer.writeByte((byte) 123); // 写入一个字节
buffer.writeInt(123456789);   // 写入一个整型（4字节）
// ... 其他写方法
  • 1.
  • 2.
  • 3.
3. 索引管理

UnpooledHeapByteBuf 使用两个索引（读索引和写索引）来管理缓冲区中的数据。读索引指向下一个要读取的字节，写索引指向下一个要写入的字节。你可以通过以下方法获取和设置索引：

  • 获取索引：
int readerIndex = buffer.readerIndex();
int writerIndex = buffer.writerIndex();
  • 1.
  • 2.
  • 设置索引：
buffer.readerIndex(newReaderIndex);
buffer.writerIndex(newWriterIndex);
  • 1.
  • 2.

注意：设置索引时要确保新的索引值在有效范围内，即 0 <= readerIndex <= writerIndex <= capacity。

4. 容量管理

UnpooledHeapByteBuf 的容量（capacity）表示缓冲区可以存储的最大字节数。你可以通过以下方法来获取和设置容量：

  • 获取容量：
int capacity = buffer.capacity();
  • 1.
  • 调整容量（注意：直接调整容量的方法可能不存在，因为 UnpooledHeapByteBuf 的容量通常是在创建时指定的。如果需要更多空间，可以考虑使用 capacity(int newCapacity) 方法来尝试调整容量，但这可能会失败或导致数据丢失，具体取决于实现）：
// 尝试调整容量，但通常不推荐这样做，因为可能会失败或导致未定义行为
// buffer.capacity(newCapacity); // 假设这个方法存在且可用，但在标准API中可能不直接提供
  • 1.
  • 2.

更常见的做法是，当需要更多空间时，使用 ensureWritable(int minWritableBytes) 方法来确保缓冲区有足够的可写空间，或者通过复制数据到新的缓冲区来间接调整容量。

5. 释放资源

由于 UnpooledHeapByteBuf 分配在 JVM 堆上，因此其生命周期由 JVM 的垃圾回收机制管理。当你不再需要缓冲区时，只需要确保没有任何引用指向它，JVM 就会在适当的时机回收它所占用的内存。

然而，如果你在使用 UnpooledHeapByteBuf 时涉及到了复杂的内存管理逻辑（例如，将缓冲区传递给其他组件或线程），那么你可能需要手动调用 release() 方法来减少引用计数，并在引用计数降为零时显式地释放缓冲区。但请注意，在标准的 Netty 使用场景中，这通常不是必需的。

五、使用场景与性能考虑

UnpooledHeapByteBuf适用于以下场景：

  • 需要独立控制内存生命周期的场景。
  • 避免池化内存管理开销的场景。
  • 数据量较小，内存分配和释放开销不是主要性能瓶颈的场景。

然而，在需要处理大量数据或高并发场景时，使用UnpooledHeapByteBuf可能会导致频繁的内存分配和释放，从而增加GC压力并降低性能。在这种情况下，使用池化的ByteBuf实现（如PooledByteBuf）可能更为合适。

总结

UnpooledHeapByteBuf是Netty中一种非池化的堆内存ByteBuf实现。它通过在JVM的堆内存中分配字节数组来存储数据，并提供了丰富的方法来访问和操作这些数据。虽然UnpooledHeapByteBuf在某些场景下可能不如池化的ByteBuf性能高效，但它在需要独立控制内存生命周期或避免池化内存管理开销的场景下是一个很好的选择。通过深入了解UnpooledHeapByteBuf的工作原理和实现细节，我们可以更好地在Netty中使用它，并根据具体需求选择合适的ByteBuf实现。

关注公众号[码到三十五]获取更多技术干货 !