【Netty】高性能原因：缓冲区内存池

蔚落 2023-01-01 11:55 148阅读 0赞

随着 JVM 虚拟机和 JIT即时编译技术的发展，对象的分配和回收是个非常轻量级的工作。但是对于缓冲区 Buffer，情况却稍有不同，特别是对于堆外直接内存的分配和回收，是一件耗时的操作。为了尽量重用缓冲区，Netty 提供了基于内存池的缓冲区重用机制。 Netty ByteBuf 继承关系如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center][]

### 1.性能对比测试 ###

Netty 提供了多种内存管理策略，通过在启动辅助类中配置相关参数，可以实现差异化的定制。下面通过性能测试，我们看下基于内存池循环利用的 ByteBuf 和普通 ByteBuf 的性能差异。

public static void main(String[] args) {
        
        final byte[] CONTENT = new byte[1024];
        int loop = 1000000; // 分配 100 万次
    
    	// 使用内存池分配器创建直接内存缓冲区
        long startTime = System.currentTimeMillis();
        ByteBuf poolBuffer = null;
        for (int i = 0; i < loop; i++) {
        
        	// 内存池分配
            poolBuffer = PooledByteBufAllocator.DEFAULT.directBuffer(1024);
            poolBuffer.writeBytes(CONTENT); 
            poolBuffer.release();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("内存池分配缓冲区耗时" + (endTime - startTime) + "ms.");
    	
    	// 使用非堆内存分配器创建的直接内存缓冲区
        long startTime2 = System.currentTimeMillis();
        ByteBuf buffer = null;
        for (int i = 0; i < loop; i++) {
        
        	// 非内存池分配
            buffer = Unpooled.directBuffer(1024);
            buffer.writeBytes(CONTENT);
        }
        endTime = System.currentTimeMillis();
        System.out.println("非内存池分配缓冲区耗时" + (endTime - startTime2) + "ms.");
    }

各执行 100 万次，性能对比结果如下：

内存池分配缓冲区耗时415ms.
    非内存池分配缓冲区耗时972ms.

性能测试表明，采用内存池的ByteBuf 相比于朝生夕灭的 ByteBuf，性能高 2.3 倍左右（性能数据与使用场景强相关）

### 2.内存分配源码 ###

下面我们一起简单分析下 Netty 内存池的内存分配：

public ByteBuf directBuffer(int initialCapacity, int maxCapacity) {
         
        if (initialCapacity == 0 && maxCapacity == 0) {
         
            return emptyBuf; 
        } 
        validate(initialCapacity, maxCapacity); 
        return newDirectBuffer(initialCapacity, maxCapacity); 
    }

继续看 newDirectBuffer 方法，它是一个抽象方法，由 AbstractByteBufAllocator的子类负责具体实现

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]

// PooledByteBufAllocator#newDirectBuffer()
    // Cache 中获取内存区域 PoolArena，调用它的 allocate 方法进行内存分配
    protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
        
        PoolThreadCache cache = threadCache.get();
        PoolArena<ByteBuffer> directArena = cache.directArena;
    
        ByteBuf buf;
        if (directArena != null) {
        
            buf = directArena.allocate(cache, initialCapacity, maxCapacity);
        } else {
        
            if (PlatformDependent.hasUnsafe()) {
        
                buf = UnsafeByteBufUtil.newUnsafeDirectByteBuf(this, initialCapacity, maxCapacity);
            } else {
        
                buf = new UnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
            }
        }
    
        return toLeakAwareBuffer(buf);
    }

PoolArena 的 allocate 方法如下：

PooledByteBuf<T> allocate(PoolThreadCache cache, int reqCapacity, int maxCapacity) {
        
        PooledByteBuf<T> buf = newByteBuf(maxCapacity);
        allocate(cache, buf, reqCapacity);
        return buf;
    }

重点分析 newByteBuf 的实现，它同样是个抽象方法，由子类 DirectArena 和 HeapArena 来实现不同类型的缓冲区分配，由于测试用例使用的是堆外内存，因此重点分析 DirectArena 的实现：

![在这里插入图片描述][20210102174901230.png_pic_center]

protected PooledByteBuf<ByteBuffer> newByteBuf(int maxCapacity) {
        
        if (HAS_UNSAFE) {
        
            return PooledUnsafeDirectByteBuf.newInstance(maxCapacity);
        // 如果没有开启使用 sun 的 unsafe
        } else {
        
            return PooledDirectByteBuf.newInstance(maxCapacity);
        }
    }

执行 PooledDirectByteBuf 的 newInstance 方法，代码如下：

static PooledDirectByteBuf newInstance(int maxCapacity) {
        
        PooledDirectByteBuf buf = RECYCLER.get();
        buf.reuse(maxCapacity);
        return buf;
    }

通过 RECYCLER 的 get 方法循环使用 ByteBuf 对象，如果是非内存池实现，则直接创建一个新的 ByteBuf 对象。从缓冲池中获取 ByteBuf 之后，调用 AbstractReferenceCountedByteBuf 的 setRefCnt 方法设置引用计数器，用于对象的引用计数和内存回收（类似JVM 垃圾回收机制）。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/e159f1633ac54116afb1681a68cdd620.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/b20fe3b71be945de816dc1a4769f5b1f.png
[20210102174901230.png_pic_center]: /images/20221120/01e25c8a7f7a4da6b9780cb098e246b3.png