Netty 如何高效使用内存

系统性能优化之内存篇 中提到了如何更好的使用内存，本篇以 netty 为例赏析 netty 中的内存使用技巧。

基本类型 vs 包装类

Java 中的对象在堆内存中的存储布局可以划分为三个部分：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。在64位虚拟机中对象头就需要占用64bit的空间，比一些基本类型（byte、short、int等）占用的空间都要大。

因此能用基本类型就不要用包装类。

变量的定义

一个类在程序执行中可能会创建多个对象，如果这个变量是实例变量，则每个类对象都会有一份，而如果定义为类变量，则所有实例共享。

Netty 作为网络通信框架，创建的 Channel 不可估量，需要统计每一个 channel 待发送的数据（判断写缓冲区是否处于“高水位”），这个字段会被 IO 线程消费减少，同时可能被业务线程生产增加，如果使用 AtomicLong 类型，则每个 channel 都会多一份对象头的开销。Netty 定义了一个 volatile 变量和一个静态的 AtomicLongFieldUpdater，大大节省了内存。

代码参见：io/netty/channel/ChannelOutboundBuffer.java

private static final AtomicLongFieldUpdater<ChannelOutboundBuffer> TOTAL_PENDING_SIZE_UPDATER;

private volatile long totalPendingSize;

预估内存

定义 HashMap、List 等可能扩容的对象时指定初始容量不必多说，Netty 会根据接受到的数据动态调整（guess）下个要分配的 Buffer 大小。

代码参见：io/netty/channel/AdaptiveRecvByteBufAllocator.java（省略部分代码）

private final class HandleImpl extends MaxMessageHandle {
    
    private int nextReceiveBufferSize;

    @Override
    public int guess() {
        return nextReceiveBufferSize;
    }

    private void record(int actualReadBytes) {
        if (actualReadBytes <= SIZE_TABLE[Math.max(0, index - INDEX_DECREMENT - 1)]) {
            if (decreaseNow) {
                index = Math.max(index - INDEX_DECREMENT, minIndex);
                nextReceiveBufferSize = SIZE_TABLE[index];
                decreaseNow = false;
            } else {
                decreaseNow = true;
            }
        } else if (actualReadBytes >= nextReceiveBufferSize) {
            index = Math.min(index + INDEX_INCREMENT, maxIndex);
            nextReceiveBufferSize = SIZE_TABLE[index];
            decreaseNow = false;
        }
    }

}

逻辑组合代替复制

当读取 channel 中的数据时，如果有新的数据来到，通过 addComponent 将新数据添加到缓冲对象里，即只是新增一个引用，无需真正复制内存。

代码参见：io/netty/handler/codec/ByteToMessageDecoder.java

/**
 * Cumulate {@link ByteBuf}s by add them to a {@link CompositeByteBuf} and so do no memory copy whenever possible.
 * Be aware that {@link CompositeByteBuf} use a more complex indexing implementation so depending on your use-case
 * and the decoder implementation this may be slower then just use the {@link #MERGE_CUMULATOR}.
 */
public static final Cumulator COMPOSITE_CUMULATOR = new Cumulator() {
    @Override
    public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
        ByteBuf buffer;
        if (cumulation.refCnt() > 1) {
            // Expand cumulation (by replace it) when the refCnt is greater then 1 which may happen when the user
            // use slice().retain() or duplicate().retain().
            //
            // See:
            // - https://github.com/netty/netty/issues/2327
            // - https://github.com/netty/netty/issues/1764
            buffer = expandCumulation(alloc, cumulation, in.readableBytes());
            buffer.writeBytes(in);
            in.release();
        } else {
            CompositeByteBuf composite;
            if (cumulation instanceof CompositeByteBuf) {
                composite = (CompositeByteBuf) cumulation;
            } else {
                composite = alloc.compositeBuffer(Integer.MAX_VALUE);
                composite.addComponent(true, cumulation);
            }
            composite.addComponent(true, in);
            buffer = composite;
        }
        return buffer;
    }
};

零拷贝

“zero-copy”既是优化内存的手段，也是优化 IO 的手段，简单来说就是 IO 读操作需要把字节从内核态拷贝到用户态的应用程序中，写操作又需要拷贝回内核的缓冲区中。如果应用程序无需对文件进行操作，那么直接在内核态进行拷贝，就可以减少拷贝次数。

Netty 在 io/netty/channel/DefaultFileRegion.java 中也是使用了 JDK 原生的零拷贝（transferTo）实现

public long transferTo(WritableByteChannel target, long position) throws IOException {
    long count = this.count - position;
    if (count < 0 || position < 0) {
        throw new IllegalArgumentException(
                "position out of range: " + position +
                " (expected: 0 - " + (this.count - 1) + ')');
    }
    if (count == 0) {
        return 0L;
    }
    if (refCnt() == 0) {
        throw new IllegalReferenceCountException(0);
    }
    // Call open to make sure fc is initialized. This is a no-oop if we called it before.
    open();

    long written = file.transferTo(this.position + position, count, target);
    if (written > 0) {
        transferred += written;
    }
    return written;
}

堆外内存

堆外内存由于不受 Java GC 的影响，更加的稳定、持久，但可能由于内存原因被操作系统杀死进程。

Netty 在池化内存池 PooledByteBufAllocator 的默认实现中设置的使用堆外内存。

private static final boolean DIRECT_BUFFER_PREFERRED =
        HAS_UNSAFE && !SystemPropertyUtil.getBoolean("io.netty.noPreferDirect", false);

io.netty.noPreferDirect 设置为 true，则使用堆内内存。

对象/内存池

io.netty.allocator.type 是一个关键的参数，它直接决定了 Netty 内部用来管理 ByteBuf 内存的分配器（Allocator）类型。简单来说，它控制着 Netty 是自己高效地管理和复用内存（池化），还是简单直接地向操作系统申请和释放内存（非池化）。非安卓平台默认是池化实现。

源码参见：io/netty/buffer/ByteBufUtil.java

static {
    String allocType = SystemPropertyUtil.get(
            "io.netty.allocator.type", PlatformDependent.isAndroid() ? "unpooled" : "pooled");
    allocType = allocType.toLowerCase(Locale.US).trim();

    ByteBufAllocator alloc;
    if ("unpooled".equals(allocType)) {
        alloc = UnpooledByteBufAllocator.DEFAULT;
        logger.debug("-Dio.netty.allocator.type: {}", allocType);
    } else if ("pooled".equals(allocType)) {
        alloc = PooledByteBufAllocator.DEFAULT;
        logger.debug("-Dio.netty.allocator.type: {}", allocType);
    } else {
        alloc = PooledByteBufAllocator.DEFAULT;
        logger.debug("-Dio.netty.allocator.type: pooled (unknown: {})", allocType);
    }

    DEFAULT_ALLOCATOR = alloc;

    THREAD_LOCAL_BUFFER_SIZE = SystemPropertyUtil.getInt("io.netty.threadLocalDirectBufferSize", 64 * 1024);
    logger.debug("-Dio.netty.threadLocalDirectBufferSize: {}", THREAD_LOCAL_BUFFER_SIZE);

    MAX_CHAR_BUFFER_SIZE = SystemPropertyUtil.getInt("io.netty.maxThreadLocalCharBufferSize", 16 * 1024);
    logger.debug("-Dio.netty.maxThreadLocalCharBufferSize: {}", MAX_CHAR_BUFFER_SIZE);
}

可通过 ServerBootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) 设置，在io/netty/buffer/PooledDirectByteBuf.java 创建 buffer 时会直接从池中取。

当创建一个对象的成本比较大，而且创建频率高且可复用时，使用对象池可以更好的节省资源。

Netty 自行实现了轻量级（相比 Apache Commons Pool）的对象池：io/netty/util/Recycler.java