netty的内存池

内存池

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

Netty 提供了多种内存管理策略，通过在启动辅助类中配置相关参数，可以实现差异化的定制。

下面通过性能测试，我们看下基于内存池循环利用的 ByteBuf 和普通 ByteBuf 的性能差异。

用例一，使用内存池分配器创建直接内存缓冲区：

final byte[] CONTENT = new byte[1024]; 
int loop = 1800000; 
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.");

各执行 180 万次，性能对比结果如下所示：

性能测试经验表明，采用内存池的 ByteBuf 相比于朝生夕灭的 ByteBuf，性能高 23 倍左右（性能数据与使用场景强相关）。下面我们一起简单分析下 Netty 内存池的内存分配：

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

继续看 newDirectBuffer 方法，我们发现它是一个抽象方法，由 AbstractByteBufAllocator 的子类负责具体实现，代码如下：

代码跳转到 PooledByteBufAllocator 的 newDirectBuffer 方法，从 Cache 中获取内存区域 PoolArena，调用它的 allocate方法进行内存分配：

@Override
    protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
        PoolThreadCache cache = threadCache.get();
        PoolArena<ByteBuffer> directArena = cache.directArena;
​
        final ByteBuf buf;
        if (directArena != null) {
            buf = directArena.allocate(cache, initialCapacity, maxCapacity);
        } else {
            buf = PlatformDependent.hasUnsafe() ?
                    UnsafeByteBufUtil.newUnsafeDirectByteBuf(this, initialCapacity, maxCapacity) :
                    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 的实现：如果没有开启使用 sun 的 unsafe，则

 @Override
        protected PooledByteBuf<ByteBuffer> newByteBuf(int maxCapacity) {
            if (HAS_UNSAFE) {
                return PooledUnsafeDirectByteBuf.newInstance(maxCapacity);
            } 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 垃圾回收机制）。