Netty 之 ByteBuf 几种分配方案及内存溢出相关Bug

迷南。 2021-10-01 12:10 1491阅读 0赞

在Netty框架中，是使用Bytebuf来操作内存缓冲区的，ByteBuf  
对Java Nio ByteBuffer进行了二次封装，以便操作起来更方便。使用分配器分配ByteBuf 的方式有哪几种呢？

从**内存回收**的角度，Bytebuf分为两类：

**第一类：基于对象池Pooled（池化）的ByteBuf**

回收的方法：放入可以重新分配的Bytebuf池子里，等待下一次分配。

可以重用Bytebuf对象，它自己维护了一个内存池，循环利用创建的Bytebuf，提升内存的使用效率，降低高负载导致的频繁GC。

**第二类：普通对象Unpooled（**未池化**）的ByteBuf**

1.  如果是Heap堆结构缓冲区，会被JVM的垃圾回收机制回收；
2.  如果是Direct直接缓冲区，调用本地释放外部内存（unsafe.freeMemory）。

这两种是主要的分配方式。

从**内存分配**的角度，ByteBuf 又可以分为两类：

**第一类：堆内存HeapBytebuf**

特点：内存的分配和回收快，可以被JVM自动回收；

缺点：如果进行Socket的I/O读写，需要额外做一次内存复制，将堆内存复制到内核Channel中，性能会有所下降。

**第二类：直接内存DirectByteBuf**

特点：非堆内存，在堆外进行内存分配，写入或者从Socket Channel中读取时，由于少了一次内存复制，速度比堆内存快；

缺点：分配和回收会慢一些。

这两种是上面两种的分支。

专家建议：在I/O通信线程的读写缓冲区使用DirectBytebuf，后端业务的编解码模式使用HeapBytebuf，这样组合可以达到性能最优。

看完上面的这段描述，是不是还搞不清楚如何为Bytebuf分配缓冲区，下面上代码，几行代码一目了然：

/**
         * 四种典型的内存分配方式
         * 性能测试，每种运行一千万次，每次分配1000个字节，并写入同样的字符串
         * @param argo
         */
        public static void main(String[] argo){
          
          Long start = System.currentTimeMillis();
          System.out.println("执行开始时间：" + start);      
          ByteBuf buf = null;   
          String str = "程就人生，程就你我";
          
          //池化直接内存
          for(int i=0;i<10000000;i++){
           buf = PooledByteBufAllocator.DEFAULT.directBuffer(1000);
           buf.writeBytes(str.getBytes());
           buf.release();
         }
          
         Long end1 = System.currentTimeMillis();
         System.out.println("PooledByteBufAllocator.DEFAULT.directBuffer 池化直接内存 ,执行结束时间：" + (end1-start));
         
         //池化堆内存
         for(int i=0;i<10000000;i++){
           buf = PooledByteBufAllocator.DEFAULT.heapBuffer(1000);
           buf.writeBytes(str.getBytes());
           buf.release();
         }
         Long end2 = System.currentTimeMillis();
         System.out.println("PooledByteBufAllocator.DEFAULT.heapBuffer 池化堆内存,执行结束时间：" + (end2-end1));
         
         //非池化直接内存 
         for(int i=0;i<10000000;i++){
           buf = Unpooled.directBuffer(1000);
           buf.writeBytes(str.getBytes());
           buf.release();
         }
         Long end3 = System.currentTimeMillis();
         System.out.println("Unpooled.directBuffer 非池化直接内存,执行结束时间：" + (end3-end2));
         
         //非池化堆内存 
         for(int i=0;i<10000000;i++){
           buf = Unpooled.buffer(1000);
           buf.release(); 
         }
         Long end4 = System.currentTimeMillis();
         System.out.println("Unpooled.buffer 非池化堆内存,执行结束时间：" + (end4-end3));
         
        }

没错，Bytebuf分配缓冲区主要有四种：池化直接内存、池化堆内存、非池化直接内存、非池化堆内存，运行一下，看看这四种分配方式的性能如何：

![3816895-566f22c076a143ac][]

图片

一千万条数据，每个分配1000字节，执行的结果如上图，非池化堆内存的性能最高，非池化直接内存的性能最低。

在使用Bytebuf时，如果内存分配使用不当，则容易报内存溢出的错误。

1. 池化直接内存的

ByteBuf buf = null;       
          //池化直接内存
          for(int i=0;i<10000000;i++){
            System.out.println(i);
           buf = PooledByteBufAllocator.DEFAULT.directBuffer(1000);
           //ReferenceCountUtil.release(buf); //不及时释放，循环至1835007次,报错：java.lang.OutOfDirectMemoryError: failed to allocate 16777216 byte(s) of direct memory (used: 3791650816, max: 3797417984)
         }

报错信息如下：

![3816895-4fe8dd372db64fcd][]

图片

2.池化堆内存的

//池化堆内存 
         for(int i=0;i<10000000;i++){
           System.out.println(i);
           buf = PooledByteBufAllocator.DEFAULT.heapBuffer(1000);
           //buf.release(); //不及时释放，循环至1556479次，报 java.lang.OutOfMemoryError: Java heap space
         }

报错信息如下：

![3816895-531c13f669ae22be][]

3.非池化直接内存

//非池化直接内存
         for(int i=0;i<10000000;i++){
           System.out.println(i);
           buf = Unpooled.directBuffer(1000);
           //buf.release(); //不及时释放，循环至1883241次，报io.netty.util.internal.OutOfDirectMemoryError: failed to allocate 1000 byte(s) of direct memory (used: 3797417000, max: 3797417984)
         }

报错信息如下：

![3816895-32b6e8eb5e6dac43][]

图片

4.非池化堆内存

//非池化堆内存
         for(int i=0;i<10000000;i++){
           System.out.println(i);       
           buf = Unpooled.buffer(1000);
           //buf.release(); //一千万行全部执行完，没有报错；
         }
         System.out.println("一千万行，执行完毕~！");

执行结果如下：

![3816895-5c64c662c2e47758][]

无论使用的是池化直接内存，还是非池化直接内存，使用过后都要及时释放，不然就会抛出内存溢出的异常。使用非池化直接内存，也需要即使释放，不然也会抛异常，只有非池化堆内存使用过后被jvm自动回收了，可以放心使用。

[3816895-566f22c076a143ac]: /images/20210811/b8bd63649ee84e5381fe96151502c805.png
[3816895-4fe8dd372db64fcd]: /images/20210811/a8eccf9dd41f46e186e8c61ee4b2cc09.png
[3816895-531c13f669ae22be]: /images/20210811/294a5d701b4443f7bb15539f3554fd17.png
[3816895-32b6e8eb5e6dac43]: /images/20210811/9f94c9d267b8449fbd13d5547af447e3.png
[3816895-5c64c662c2e47758]: /images/20210811/ce187986ade14062921f8cac59a9fc6e.png