吃透Netty源码系列十六之UnpooledHeapByteBuf

最新推荐文章于 2024-07-31 10:30:00 发布

王伟王胖胖

最新推荐文章于 2024-07-31 10:30:00 发布

阅读量1.8k

点赞数 2

分类专栏：吃透Netty源码系列文章标签：吃透Netty源码系列 Netty源码解析 Netty 多路复用 nio

本文链接：https://blog.csdn.net/wangwei19871103/article/details/104258551

版权

吃透Netty源码系列专栏收录该内容

64 篇文章 297 订阅

订阅专栏

吃透Netty源码系列十六之UnpooledHeapByteBuf

UnpooledHeapByteBuf
UnpooledUnsafeHeapByteBuf
- allocateArray
- UnsafeByteBufUtil
InstrumentedUnpooledHeapByteBuf
总结

UnpooledHeapByteBuf

引用计数缓冲区的子类，非池化的堆缓冲区，也就是内存在java堆里，内部其实就是分配了一个数组。这里还有个字节序的概念，也就是说字节是放在地址的高低位的区别。简单的说下，主要分两种，一种是小端字节序，也就是一般内存存放数据的，高字节放在高位地址，低地址放低位地址，而大端刚好是相反，一般用于网络通信获取的字节数据。比如16位数据是0xf123放在字长为2个字节的地址里，如果小端就是高位放f1低位放23，如果是大端就是高位放23低位放f1 。好像挺麻烦的，不就是个存放么，为什么不统一呢，这个貌似是历史遗留原因。
在这里插入图片描述
我们再来看看他的继承情况：

主要属性

可以看到，内部是一个数组，然后包装成ByteBuffer 。

    private final ByteBufAllocator alloc;//缓冲区分配器
    byte[] array;//内部是字节数组
    private ByteBuffer tmpNioBuf;//用ByteBuffer来包装array数组

构造方法

可以看到，这个构造方法就是会创建一个initialCapacity大小的数组。

 public UnpooledHeapByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(maxCapacity);

        if (initialCapacity > maxCapacity) {
            throw new IllegalArgumentException(String.format(
                    "initialCapacity(%d) > maxCapacity(%d)", initialCapacity, maxCapacity));
        }

        this.alloc = checkNotNull(alloc, "alloc");
        setArray(allocateArray(initialCapacity));
        setIndex(0, 0);
    }
//申请字节数组空间
    protected byte[] allocateArray(int initialCapacity) {
        return new byte[initialCapacity];
    }

而这个方法是直接设置数组。

 protected UnpooledHeapByteBuf(ByteBufAllocator alloc, byte[] initialArray, int maxCapacity) {
        super(maxCapacity);

        checkNotNull(alloc, "alloc");
        checkNotNull(initialArray, "initialArray");
        if (initialArray.length > maxCapacity) {
            throw new IllegalArgumentException(String.format(
                    "initialCapacity(%d) > maxCapacity(%d)", initialArray.length, maxCapacity));
        }

        this.alloc = alloc;
        setArray(initialArray);
        setIndex(0, initialArray.length);
    }
//设置数组
    private void setArray(byte[] initialArray) {
        array = initialArray;
        tmpNioBuf = null;
    }

字节序

从网络里面获取的字节系默认是大端的。

//大端字节序
    @Override
    public ByteOrder order() {
        return ByteOrder.BIG_ENDIAN;
    }

比如以int的类型去读取数组：


  @Override
    public int getInt(int index) {
        ensureAccessible();
        return _getInt(index);
    }

    @Override
    protected int _getInt(int index) {
        return HeapByteBufUtil.getInt(array, index);
    }

至于字节序怎么转换的，有个辅助类HeapByteBufUtil，里面默认是大端的，但是也可以用小端的方法，后面是LE结尾的，比如下面的，用int类型来取数据，默认大端取。

//大端取 低位地址取出来的方法高位
    static int getInt(byte[] memory, int index) {
        return  (memory[index]     & 0xff) << 24 |
                (memory[index + 1] & 0xff) << 16 |
                (memory[index + 2] & 0xff) <<  8 |
                memory[index + 3] & 0xff;
    }
    //小端取 低位地址取出来的放低位
   static int getIntLE(byte[] memory, int index) {
        return  memory[index]      & 0xff        |
                (memory[index + 1] & 0xff) << 8  |
                (memory[index + 2] & 0xff) << 16 |
                (memory[index + 3] & 0xff) << 24;
    }
    //大端设置 高位数据放低位
    static void setInt(byte[] memory, int index, int value) {
        memory[index]     = (byte) (value >>> 24);
        memory[index + 1] = (byte) (value >>> 16);
        memory[index + 2] = (byte) (value >>> 8);
        memory[index + 3] = (byte) value;
    }
	//小端设置 低位数据放低位
    static void setIntLE(byte[] memory, int index, int value) {
        memory[index]     = (byte) value;
        memory[index + 1] = (byte) (value >>> 8);
        memory[index + 2] = (byte) (value >>> 16);
        memory[index + 3] = (byte) (value >>> 24);
    }

internalNioBuffer

这个就是将数据包装成ByteBuffer。

    private ByteBuffer internalNioBuffer() {
        ByteBuffer tmpNioBuf = this.tmpNioBuf;
        if (tmpNioBuf == null) {
            this.tmpNioBuf = tmpNioBuf = ByteBuffer.wrap(array);
        }
        return tmpNioBuf;
    }

capacity

可以看到，扩容的话可能会做数组的拷贝。

 @Override
    public ByteBuf capacity(int newCapacity) {
        checkNewCapacity(newCapacity);
        byte[] oldArray = array;
        int oldCapacity = oldArray.length;
        if (newCapacity == oldCapacity) {
            return this;
        }

        int bytesToCopy;
        if (newCapacity > oldCapacity) {//增加容量
            bytesToCopy = oldCapacity;
        } else {//减少容量
            trimIndicesToCapacity(newCapacity);
            bytesToCopy = newCapacity;
        }
        byte[] newArray = allocateArray(newCapacity);
        System.arraycopy(oldArray, 0, newArray, 0, bytesToCopy);//数组拷贝
        setArray(newArray);
        freeArray(oldArray);//空方法，gc去释放
        return this;
    }

其他方法都比较好理解就不多说了，只要知道这个缓冲区内部是数组，由java虚拟机来管理内存，默认存取都是大端字节序。

UnpooledUnsafeHeapByteBuf

在这里插入图片描述
这个继承了上面的就比上面的多了一个Unsafe，也就是说好多操作应该是unsafe类做的。

allocateArray

比如这个分配内存的方法，用到了PlatformDependent平台相关的类，最后是用反射做的，因为unsafe只能java内部自己用，外面要用可以用反射。

    @Override
    protected byte[] allocateArray(int initialCapacity) {
        return PlatformDependent.allocateUninitializedArray(initialCapacity);
    }

   public static byte[] allocateUninitializedArray(int size) {
        return UNINITIALIZED_ARRAY_ALLOCATION_THRESHOLD < 0 || UNINITIALIZED_ARRAY_ALLOCATION_THRESHOLD > size ?
                new byte[size] : PlatformDependent0.allocateUninitializedArray(size);
    }
    static byte[] allocateUninitializedArray(int size) {
        try {
            return (byte[]) ALLOCATE_ARRAY_METHOD.invoke(INTERNAL_UNSAFE, byte.class, size);
        } catch (IllegalAccessException e) {
            throw new Error(e);
        } catch (InvocationTargetException e) {
            throw new Error(e);
        }
    }

UnsafeByteBufUtil

当然他也是大端字节序，用的是这个工具类。

    @Override
    public int getInt(int index) {
        checkIndex(index, 4);
        return _getInt(index);
    }

    @Override
    protected int _getInt(int index) {
        return UnsafeByteBufUtil.getInt(array, index);
    }

内部也是PlatformDependent类。

 static int getInt(byte[] array, int index) {
        if (UNALIGNED) {
            int v = PlatformDependent.getInt(array, index);
            return BIG_ENDIAN_NATIVE_ORDER ? v : Integer.reverseBytes(v);
        }
        return PlatformDependent.getByte(array, index) << 24 |
               (PlatformDependent.getByte(array, index + 1) & 0xff) << 16 |
               (PlatformDependent.getByte(array, index + 2) & 0xff) <<  8 |
               PlatformDependent.getByte(array, index + 3) & 0xff;
    }

    static int getIntLE(byte[] array, int index) {
        if (UNALIGNED) {
            int v = PlatformDependent.getInt(array, index);
            return BIG_ENDIAN_NATIVE_ORDER ? Integer.reverseBytes(v) : v;
        }
        return PlatformDependent.getByte(array, index)      & 0xff        |
               (PlatformDependent.getByte(array, index + 1) & 0xff) <<  8 |
               (PlatformDependent.getByte(array, index + 2) & 0xff) << 16 |
               PlatformDependent.getByte(array,  index + 3) << 24;
    }

底层也是调用unsafe的方法，UNSAFE就是unsafe，只是通过反射来获取的：

    static int getInt(byte[] data, int index) {
        return UNSAFE.getInt(data, BYTE_ARRAY_BASE_OFFSET + index);
    }

InstrumentedUnpooledHeapByteBuf

在这里插入图片描述
这个前面又加了形容词，其实就是记录了申请和释放的时候记录字节数，InstrumentedUnpooledUnsafeHeapByteBuf也是类似的，就不多说了：

 //仪表化的无池化的堆缓冲区
    private static final class InstrumentedUnpooledHeapByteBuf extends UnpooledHeapByteBuf {
        InstrumentedUnpooledHeapByteBuf(UnpooledByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
            super(alloc, initialCapacity, maxCapacity);
        }

        @Override
        protected byte[] allocateArray(int initialCapacity) {
            byte[] bytes = super.allocateArray(initialCapacity);//申请了字节数组
            ((UnpooledByteBufAllocator) alloc()).incrementHeap(bytes.length);//增加堆字节
            return bytes;
        }
//实现了释放内部字节数组
        @Override
        protected void freeArray(byte[] array) {
            int length = array.length;
            super.freeArray(array);
            ((UnpooledByteBufAllocator) alloc()).decrementHeap(length);//减少堆字节
        }
    }