【Netty】五.ByteBuf内存管理深度剖析

写在前面

在Java网络编程中，字节缓冲区是最基础的数据容器。JDK提供了ByteBuffer，但其设计存在诸多不足------固定长度、缺乏动态扩容、API不够友好。Netty重新设计了ByteBuf，不仅解决了ByteBuffer的问题，还引入了池化内存、引用计数、零拷贝等高级特性。

这篇文章将深入剖析ByteBuf的设计原理、内存管理策略，以及如何正确使用ByteBuf避免内存泄漏。

一、JDK ByteBuffer的痛点

1.1 ByteBuffer基础用法

// 创建ByteBuffer
ByteBuffer buffer = ByteBuffer.allocate(1024);  // 堆内存
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);  // 直接内存

// 写入数据
buffer.put("Hello".getBytes());

// 切换为读模式
buffer.flip();

// 读取数据
byte[] data = new byte[buffer.remaining()];
buffer.get(data);

// 清空缓冲区
buffer.clear();

1.2 ByteBuffer的问题

问题一：读写切换繁琐

// 写入数据后，需要flip才能读取
buffer.put("Hello".getBytes());
buffer.flip();  // 必须调用flip切换为读模式
buffer.get();

// 读取后，需要clear或compact才能再次写入
buffer.clear();  // 或 buffer.compact();

每次读写切换都需要调用flip()、clear()、compact()，容易遗漏或调用错误。

问题二：固定长度，无法动态扩容

ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put("Hello World".getBytes());  // 抛出BufferOverflowException！

ByteBuffer一旦创建，容量就固定了，无法动态扩展。需要手动创建更大的Buffer并复制数据。

问题三：缺乏高级功能

• 没有引用计数，无法自动释放
• 没有内存池，频繁创建销毁影响性能
• 没有便捷的类型读写方法

二、ByteBuf的设计改进

2.1 ByteBuf结构

ByteBuf使用两个指针维护读写位置：

┌─────────────────────────────────────────────────────────────────────────┐
│                          ByteBuf结构                                     │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│      +-------------------+------------------+------------------+        │
│      | discardable bytes |  readable bytes  |  writable bytes  |        │
│      |                   |     (CONTENT)    |                  |        │
│      +-------------------+------------------+------------------+        │
│      |                   |                  |                  |        │
│      0      <=      readerIndex   <=   writerIndex    <=    capacity   │
│                                                                         │
│                                                                         │
│      丢弃区域              可读区域            可写区域                   │
│      (已读数据)           (未读数据)          (剩余空间)                   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

核心属性：

public abstract class AbstractByteBuf extends ByteBuf {
    // 读指针
    protected int readerIndex;
    
    // 写指针
    protected int writerIndex;
    
    // 标记的读指针
    protected int markedReaderIndex;
    
    // 标记的写指针
    protected int markedWriterIndex;
    
    // 最大容量
    protected int maxCapacity;
}

2.2 读写操作无需切换

ByteBuf buffer = Unpooled.buffer(10);

// 写入数据
buffer.writeBytes("Hello".getBytes());  // writerIndex自动增加

// 读取数据
byte[] data = new byte[5];
buffer.readBytes(data);  // readerIndex自动增加

// 再次写入，无需flip
buffer.writeBytes("World".getBytes());  // 直接写入

// 获取可读字节数
int readable = buffer.readableBytes();  // writerIndex - readerIndex

// 获取可写字节数
int writable = buffer.writableBytes();  // capacity - writerIndex

2.3 动态扩容

ByteBuf buffer = Unpooled.buffer(10);

// 写入超过容量的数据
buffer.writeBytes("Hello World, this is a long message".getBytes());

// 自动扩容成功
System.out.println("Capacity: " + buffer.capacity());  // 输出扩容后的容量

扩容源码：

// AbstractByteBuf.writeBytes
@Override
public ByteBuf writeBytes(byte[] src) {
    writeBytes(src, 0, src.length);
    return this;
}

@Override
public ByteBuf writeBytes(byte[] src, int srcIndex, int length) {
    ensureWritable(length);  // 确保有足够空间
    setBytes(writerIndex, src, srcIndex, length);
    writerIndex += length;
    return this;
}

@Override
public ByteBuf ensureWritable(int minWritableBytes) {
    if (minWritableBytes < 0) {
        throw new IllegalArgumentException("minWritableBytes: " + minWritableBytes);
    }
    ensureWritable0(minWritableBytes);
    return this;
}

private void ensureWritable0(int minWritableBytes) {
    if (minWritableBytes <= writableBytes()) {
        return;  // 空间足够
    }
    
    if (minWritableBytes > maxCapacity - writerIndex) {
        throw new IndexOutOfBoundsException("writerIndex(" + writerIndex 
                + ") + minWritableBytes(" + minWritableBytes 
                + ") exceeds maxCapacity(" + maxCapacity + ")");
    }
    
    // 扩容
    int newCapacity = calculateNewCapacity(writerIndex + minWritableBytes);
    capacity(newCapacity);  // 设置新容量
}

// 计算新容量
private int calculateNewCapacity(int minNewCapacity) {
    final int maxCapacity = this.maxCapacity;
    final int threshold = 4 * 1024 * 1024;  // 4MB阈值
    
    if (minNewCapacity == threshold) {
        return threshold;
    }
    
    if (minNewCapacity > threshold) {
        // 超过阈值，按4MB步进
        int newCapacity = minNewCapacity / threshold * threshold;
        if (newCapacity > maxCapacity - threshold) {
            return maxCapacity;
        }
        return newCapacity + threshold;
    }
    
    // 未超过阈值，翻倍扩容
    int newCapacity = 64;
    while (newCapacity < minNewCapacity) {
        newCapacity <<= 1;  // 翻倍
    }
    
    return Math.min(newCapacity, maxCapacity);
}

扩容策略：

• 小于4MB：翻倍扩容（64 → 128 → 256 → ...）
• 大于等于4MB：按4MB步进扩容

2.4 丰富的读写API

ByteBuf buffer = Unpooled.buffer(1024);

// 写入各种类型
buffer.writeBoolean(true);
buffer.writeByte(127);
buffer.writeShort(32767);
buffer.writeInt(Integer.MAX_VALUE);
buffer.writeLong(Long.MAX_VALUE);
buffer.writeFloat(3.14f);
buffer.writeDouble(3.141592653589793);
buffer.writeChar('A');
buffer.writeBytes("Hello".getBytes());
buffer.writeCharSequence("World", StandardCharsets.UTF_8);

// 读取各种类型
boolean b = buffer.readBoolean();
byte by = buffer.readByte();
short s = buffer.readShort();
int i = buffer.readInt();
long l = buffer.readLong();
float f = buffer.readFloat();
double d = buffer.readDouble();
char c = buffer.readChar();
ByteBuf slice = buffer.readBytes(5);
CharSequence cs = buffer.readCharSequence(5, StandardCharsets.UTF_8);

// get/set系列（不移动指针）
int value = buffer.getInt(0);  // 从位置0读取int
buffer.setInt(0, 100);  // 设置位置0的int值

三、ByteBuf的分类

3.1 按内存类型分类

┌─────────────────────────────────────────────────────────────────────────┐
│                        ByteBuf分类                                       │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   按内存类型：                                                           │
│                                                                         │
│   ┌─────────────────────────────────────────────────────────────────┐  │
│   │                      ByteBuf                                    │  │
│   └────────────────────────────┬────────────────────────────────────┘  │
│                                │                                        │
│              ┌─────────────────┴─────────────────┐                      │
│              │                                   │                      │
│              ▼                                   ▼                      │
│   ┌─────────────────────┐             ┌─────────────────────┐          │
│   │    Heap ByteBuf     │             │   Direct ByteBuf    │          │
│   │    (堆内存)          │             │   (直接内存)         │          │
│   │                     │             │                     │          │
│   │  - 在JVM堆中分配     │             │  - 在堆外内存分配     │          │
│   │  - GC可回收          │             │  - 不受GC管理        │          │
│   │  - 读写需要拷贝      │             │  - 零拷贝友好        │          │
│   └─────────────────────┘             └─────────────────────┘          │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Heap ByteBuf：

// 创建堆内存ByteBuf
ByteBuf heapBuffer = Unpooled.buffer(1024);
ByteBuf heapBuffer2 = Unpooled.wrappedBuffer(new byte[1024]);

// 特点
// 1. 在JVM堆中分配，受GC管理
// 2. 访问速度快（在堆中）
// 3. 网络传输时需要拷贝到直接内存

Direct ByteBuf：

// 创建直接内存ByteBuf
ByteBuf directBuffer = Unpooled.directBuffer(1024);
ByteBuf directBuffer2 = ByteBufAllocator.DEFAULT.directBuffer(1024);

// 特点
// 1. 在堆外内存分配，不受GC管理
// 2. 网络传输时无需拷贝（零拷贝）
// 3. 分配和释放成本较高

3.2 按内存池分类

┌─────────────────────────────────────────────────────────────────────────┐
│                        内存池分类                                        │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   ┌─────────────────────────────────────────────────────────────────┐  │
│   │                      ByteBuf                                    │  │
│   └────────────────────────────┬────────────────────────────────────┘  │
│                                │                                        │
│              ┌─────────────────┴─────────────────┐                      │
│              │                                   │                      │
│              ▼                                   ▼                      │
│   ┌─────────────────────┐             ┌─────────────────────┐          │
│   │   Unpooled ByteBuf  │             │   Pooled ByteBuf    │          │
│   │   (非池化)           │             │   (池化)            │          │
│   │                     │             │                     │          │
│   │  - 每次创建新对象    │             │  - 从内存池获取      │          │
│   │  - 适合低频使用      │             │  - 适合高频使用      │          │
│   │  - 无内存碎片问题    │             │  - 减少GC压力        │          │
│   └─────────────────────┘             └─────────────────────┘          │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Unpooled ByteBuf：

// 非池化ByteBuf
ByteBuf buffer = Unpooled.buffer(1024);

// 每次调用都创建新对象
ByteBuf buffer1 = Unpooled.buffer(1024);
ByteBuf buffer2 = Unpooled.buffer(1024);
// buffer1和buffer2是不同的对象

Pooled ByteBuf：

// 池化ByteBuf
ByteBufAllocator allocator = new PooledByteBufAllocator();
ByteBuf buffer1 = allocator.buffer(1024);
ByteBuf buffer2 = allocator.buffer(1024);

// 使用完毕后释放
buffer1.release();
buffer2.release();

// 释放后内存归还到池中，可被复用

3.3 如何选择

|---------|-----------------|-------------|
| 场景 | 推荐类型 | 原因 |
| 高频网络I/O | Pooled + Direct | 零拷贝，减少GC |
| 低频简单操作 | Unpooled + Heap | 简单易用，无需考虑释放 |
| 大文件传输 | Direct | 避免大块堆内存拷贝 |
| 业务逻辑处理 | Heap | 访问速度快，便于调试 |

四、内存池实现原理

4.1 为什么需要内存池

问题一：频繁分配释放影响性能

// 每次消息处理都创建新的ByteBuf
public void handleMessage(ChannelHandlerContext ctx, ByteBuf msg) {
    ByteBuf response = Unpooled.buffer(1024);  // 分配内存
    // 处理...
    response.release();  // 释放内存
}

// 高并发下，每秒可能创建数万个ByteBuf
// 频繁的内存分配和释放严重影响性能

问题二：增加GC压力

// 大量ByteBuf对象增加GC压力
// 特别是DirectByteBuffer，GC回收效率低

4.2 PoolArena结构

Netty的内存池采用类似jemalloc的设计：

┌─────────────────────────────────────────────────────────────────────────┐
│                        PoolArena结构                                     │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   ┌─────────────────────────────────────────────────────────────────┐  │
│   │                       PoolArena                                  │  │
│   ├─────────────────────────────────────────────────────────────────┤  │
│   │                                                                 │  │
│   │   ┌─────────────────────────────────────────────────────────┐  │  │
│   │   │              Small Subpage Pool (小内存)                 │  │  │
│   │   │   [16B] [32B] [48B] ... [496B] [512B] [1024B] [2048B]   │  │  │
│   │   │    │     │     │         │       │       │        │     │  │  │
│   │   │   PoolSubpage数组，每个元素是一个内存块链表              │  │  │
│   │   └─────────────────────────────────────────────────────────┘  │  │
│   │                                                                 │  │
│   │   ┌─────────────────────────────────────────────────────────┐  │  │
│   │   │              Chunk List (大内存)                         │  │  │
│   │   │                                                         │  │  │
│   │   │   ┌─────────┐   ┌─────────┐   ┌─────────┐              │  │  │
│   │   │   │ PoolChunk│──▶│ PoolChunk│──▶│ PoolChunk│ ...         │  │  │
│   │   │   │ (4MB)   │   │ (4MB)   │   │ (4MB)   │              │  │  │
│   │   │   └─────────┘   └─────────┘   └─────────┘              │  │  │
│   │   │                                                         │  │  │
│   │   │   每个PoolChunk是一个4MB的内存块                         │  │  │
│   │   └─────────────────────────────────────────────────────────┘  │  │
│   │                                                                 │  │
│   └─────────────────────────────────────────────────────────────────┘  │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

4.3 内存分配策略

// PooledByteBufAllocator.newHeapBuffer
@Override
protected ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity) {
    PoolThreadCache cache = threadCache.get();
    PoolArena<byte[]> heapArena = cache.heapArena;
    
    ByteBuf buf;
    if (heapArena != null) {
        buf = heapArena.allocate(cache, initialCapacity, maxCapacity);
    } else {
        buf = new UnpooledHeapByteBuf(this, initialCapacity, maxCapacity);
    }
    return toLeakAwareBuffer(buf);
}

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

private void allocate(PoolThreadCache cache, int reqCapacity, PooledByteBuf<T> buf) {
    final int normCapacity = normalizeCapacity(reqCapacity);
    
    if (isTinyOrSmall(normCapacity)) {
        // 小于28KB，使用Subpage分配
        int tableIdx;
        PoolSubpage<T>[] table;
        if (isTiny(normCapacity)) {
            // 小于512B
            tableIdx = tinyIdx(normCapacity);
            table = tinySubpagePools;
        } else {
            // 512B ~ 28KB
            tableIdx = smallIdx(normCapacity);
            table = smallSubpagePools;
        }
        
        final PoolSubpage<T> subpage = table[tableIdx];
        synchronized (subpage) {
            subpage.allocate(buf, normCapacity);
        }
    } else {
        // 大于等于28KB，使用Chunk分配
        allocateNormal(buf, normCapacity);
    }
}

分配流程图：

┌─────────────────────────────────────────────────────────────────────────┐
│                        内存分配流程                                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   allocate(reqCapacity)                                                 │
│          │                                                              │
│          ▼                                                              │
│   ┌─────────────────┐                                                   │
│   │ normalizeCapacity│  ← 对齐到2的幂次方                                │
│   └────────┬────────┘                                                   │
│            │                                                            │
│            ▼                                                            │
│   ┌─────────────────┐     是      ┌─────────────────────────────────┐  │
│   │ isTinyOrSmall?  │───────────▶│ 从PoolSubpage分配                │  │
│   └────────┬────────┘             │ (小于28KB)                       │  │
│            │ 否                    │                                  │  │
│            ▼                       │ 1. 先从ThreadCache查找            │  │
│   ┌─────────────────┐             │ 2. 再从PoolSubpage查找            │  │
│   │ allocateNormal  │             │ 3. 最后创建新的PoolSubpage        │  │
│   │ (大于等于28KB)   │             └─────────────────────────────────┘  │
│   └────────┬────────┘                                                   │
│            │                                                            │
│            ▼                                                            │
│   ┌─────────────────────────────────────────────────────────────────┐  │
│   │ 从PoolChunk分配                                                  │  │
│   │                                                                  │  │
│   │ 1. 先从ThreadCache查找                                           │  │
│   │ 2. 再从PoolChunkList查找                                         │  │
│   │ 3. 最后创建新的PoolChunk                                         │  │
│   └─────────────────────────────────────────────────────────────────┘  │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

4.4 ThreadLocal缓存

为了减少锁竞争，Netty为每个线程维护了本地缓存：

// PoolThreadCache
final class PoolThreadCache {
    
    // Heap Arena
    final PoolArena<byte[]> heapArena;
    
    // Direct Arena
    final PoolArena<ByteBuffer> directArena;
    
    // 小内存缓存
    private final MemoryRegionCache<byte[]>[] tinySubPageHeapCaches;
    private final MemoryRegionCache<ByteBuffer>[] tinySubPageDirectCaches;
    
    // 中等内存缓存
    private final MemoryRegionCache<byte[]>[] smallSubPageHeapCaches;
    private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;
    
    // 大内存缓存
    private final MemoryRegionCache<byte[]>[] normalHeapCaches;
    private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;
    
    // 分配时优先从缓存获取
    boolean allocateTiny(MemoryRegionCache<?>[] cache, PooledByteBuf<?> buf, 
            int reqCapacity, int normCapacity) {
        return allocate(cache, buf, reqCapacity, normCapacity);
    }
    
    // 释放时优先放入缓存
    boolean free(MemoryRegionCache<?> cache, ByteBuf buf) {
        return cache.add(buf);
    }
}

缓存结构：

┌─────────────────────────────────────────────────────────────────────────┐
│                        ThreadLocal缓存                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   Thread-1                              Thread-2                        │
│   ┌─────────────────────┐              ┌─────────────────────┐         │
│   │  PoolThreadCache    │              │  PoolThreadCache    │         │
│   │                     │              │                     │         │
│   │  tinyCaches[32]     │              │  tinyCaches[32]     │         │
│   │  smallCaches[4]     │              │  smallCaches[4]     │         │
│   │  normalCaches[3]    │              │  normalCaches[3]    │         │
│   │                     │              │                     │         │
│   └─────────────────────┘              └─────────────────────┘         │
│            │                                     │                      │
│            │                                     │                      │
│            └─────────────────┬───────────────────┘                      │
│                              │                                          │
│                              ▼                                          │
│                    ┌─────────────────┐                                  │
│                    │   PoolArena     │  （共享）                         │
│                    └─────────────────┘                                  │
│                                                                         │
│   每个线程有自己的缓存，无锁分配                                          │
│   缓存满了才归还到共享Arena                                               │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

五、引用计数机制

5.1 引用计数原理

ByteBuf使用引用计数来管理生命周期：

public interface ReferenceCounted {
    // 获取引用计数
    int refCnt();
    
    // 增加引用计数
    ReferenceCounted retain();
    
    // 增加指定数量的引用计数
    ReferenceCounted retain(int increment);
    
    // 减少引用计数
    boolean release();
    
    // 减少指定数量的引用计数
    boolean release(int decrement);
}

引用计数规则：

┌─────────────────────────────────────────────────────────────────────────┐
│                        引用计数规则                                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   创建ByteBuf：refCnt = 1                                               │
│                                                                         │
│   调用retain()：refCnt++                                                │
│                                                                         │
│   调用release()：refCnt--                                               │
│                                                                         │
│   当refCnt == 0时：                                                     │
│   - 池化ByteBuf：归还到内存池                                            │
│   - 非池化ByteBuf：释放内存                                              │
│                                                                         │
│   ┌─────────────────────────────────────────────────────────────────┐  │
│   │                                                                 │  │
│   │   ByteBuf buf = allocator.buffer(1024);  // refCnt = 1         │  │
│   │                                                                 │  │
│   │   buf.retain();    // refCnt = 2                               │  │
│   │   buf.retain();    // refCnt = 3                               │  │
│   │                                                                 │  │
│   │   buf.release();   // refCnt = 2                               │  │
│   │   buf.release();   // refCnt = 1                               │  │
│   │   buf.release();   // refCnt = 0, 内存被回收                    │  │
│   │                                                                 │  │
│   └─────────────────────────────────────────────────────────────────┘  │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

5.2 源码分析

// AbstractReferenceCountedByteBuf
public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
    
    // 引用计数字段，使用AtomicIntegerFieldUpdater保证原子性
    private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater =
            AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
    
    private volatile int refCnt = 1;
    
    @Override
    public int refCnt() {
        return refCntUpdater.get(this);
    }
    
    @Override
    public ByteBuf retain() {
        return retain0(1);
    }
    
    @Override
    public ByteBuf retain(int increment) {
        return retain0(checkPositive(increment, "increment"));
    }
    
    private ByteBuf retain0(int increment) {
        // 使用CAS更新引用计数
        int oldRef = refCntUpdater.getAndAdd(this, increment);
        if (oldRef <= 0 || oldRef + increment < oldRef) {
            // 引用计数溢出或已经释放
            refCntUpdater.getAndAdd(this, -increment);
            throw new IllegalReferenceCountException(oldRef, increment);
        }
        return this;
    }
    
    @Override
    public boolean release() {
        return release0(1);
    }
    
    @Override
    public boolean release(int decrement) {
        return release0(checkPositive(decrement, "decrement"));
    }
    
    private boolean release0(int decrement) {
        int oldRef = refCntUpdater.getAndAdd(this, -decrement);
        if (oldRef == decrement) {
            // 引用计数降为0，执行回收
            deallocate();
            return true;
        } else if (oldRef < decrement) {
            // 引用计数已经为0，重复释放
            refCntUpdater.getAndAdd(this, decrement);
            throw new IllegalReferenceCountException(oldRef, -decrement);
        }
        return false;
    }
    
    // 子类实现具体的释放逻辑
    protected abstract void deallocate();
}

5.3 引用计数的使用场景

场景一：消息转发

public class ForwardHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf buf = (ByteBuf) msg;
        
        // 转发给多个接收者
        for (Channel recipient : recipients) {
            buf.retain();  // 增加引用计数
            recipient.writeAndFlush(buf).addListener((ChannelFutureListener) future -> {
                if (!future.isSuccess()) {
                    buf.release();  // 发送失败也要释放
                }
            });
        }
        
        // 释放原始消息
        buf.release();
    }
}

场景二：消息派生

public class SliceHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf buf = (ByteBuf) msg;
        
        // 切片共享底层内存
        ByteBuf slice1 = buf.readSlice(10);  // 引用计数不变
        ByteBuf slice2 = buf.readSlice(10);
        
        // 需要手动retain
        slice1.retain();
        slice2.retain();
        
        // 处理切片...
        
        // 释放
        slice1.release();
        slice2.release();
        buf.release();
    }
}

场景三：SimpleChannelInboundHandler自动释放

// SimpleChannelInboundHandler会自动释放消息
public class MyHandler extends SimpleChannelInboundHandler<ByteBuf> {
    
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {
        // 处理消息
        // 方法返回后，msg会自动release()
        // 无需手动释放
    }
}

六、内存泄漏检测

6.1 泄漏检测机制

Netty提供了内存泄漏检测机制，通过采样检测未正确释放的ByteBuf：

// ResourceLeakDetector
public class ResourceLeakDetector<T> {
    
    // 检测级别
    public enum Level {
        DISABLED,     // 禁用检测
        SIMPLE,       // 简单检测（默认，1/128采样）
        ADVANCED,     // 高级检测（1/128采样，记录访问点）
        PARANOID      // 偏执检测（100%采样，记录所有访问点）
    }
    
    // 创建泄漏记录
    public ResourceLeakTracker<T> track(T obj) {
        Level level = this.level;
        if (level == Level.DISABLED) {
            return null;
        }
        
        if (level.ordinal() < Level.PARANOID.ordinal()) {
            // 采样检测
            if (random.nextInt(samplingInterval) != 0) {
                return null;
            }
        }
        
        return new DefaultResourceLeak(obj);
    }
    
    // DefaultResourceLeak
    private final class DefaultResourceLeak extends WeakReference<Object> 
            implements ResourceLeakTracker<T> {
        
        private final String creationRecord;
        private final Deque<String> lastRecords = new ArrayDeque<>();
        
        DefaultResourceLeak(Object referent) {
            super(referent, refQueue);
            // 记录创建时的调用栈
            this.creationRecord = record();
        }
        
        @Override
        public void record() {
            // 记录访问点
            lastRecords.add(record());
        }
        
        @Override
        public boolean close() {
            // 正常关闭，移除跟踪
            return trackedHash.remove(this);
        }
    }
}

6.2 配置检测级别

// 启动参数配置
// -Dio.netty.leakDetection.level=PARANOID

// 或代码配置
System.setProperty("io.netty.leakDetection.level", "PARANOID");

各级别对比：

|----------|-------|------|-------------|
| 级别 | 采样率 | 性能影响 | 适用场景 |
| DISABLED | 0% | 无 | 生产环境（确认无泄漏） |
| SIMPLE | 1/128 | 很小 | 生产环境（默认） |
| ADVANCED | 1/128 | 小 | 测试环境 |
| PARANOID | 100% | 较大 | 调试泄漏问题 |

6.3 泄漏告警示例

当检测到内存泄漏时，日志会输出类似以下信息：

LEAK: ByteBuf.release() was not called before it's garbage-collected. 
See https://netty.io/wiki/reference-counted-objects.html for more information.
Recent access records: 
#1:
    io.netty.buffer.AdvancedLeakAwareByteBuf.writeBytes(AdvancedLeakAwareByteBuf.java:642)
    com.example.MyHandler.channelRead(MyHandler.java:25)
    io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:965)
#2:
    io.netty.buffer.AdvancedLeakAwareByteBuf.writeBytes(AdvancedLeakAwareByteBuf.java:642)
    io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:965)
Created at:
    io.netty.buffer.PooledByteBufAllocator.newDirectBuffer(PooledByteBufAllocator.java:331)
    io.netty.buffer.AbstractByteBufAllocator.directBuffer(AbstractByteBufAllocator.java:185)
    io.netty.buffer.AbstractByteBufAllocator.buffer(AbstractByteBufAllocator.java:122)
    com.example.MyHandler.channelRead(MyHandler.java:20)

6.4 常见泄漏场景与修复

场景一：忘记释放

// 错误示例
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    ByteBuf buf = (ByteBuf) msg;
    // 处理消息但忘记释放
    processMessage(buf);
    // 泄漏！
}

// 正确做法
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    ByteBuf buf = (ByteBuf) msg;
    try {
        processMessage(buf);
    } finally {
        buf.release();  // 确保释放
    }
}

// 或使用SimpleChannelInboundHandler
public class MyHandler extends SimpleChannelInboundHandler<ByteBuf> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {
        processMessage(msg);
        // 自动释放
    }
}

场景二：异常导致未释放

// 错误示例
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    ByteBuf buf = (ByteBuf) msg;
    processMessage(buf);  // 可能抛异常
    buf.release();  // 异常时不执行
}

// 正确做法
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    ByteBuf buf = (ByteBuf) msg;
    try {
        processMessage(buf);
    } finally {
        buf.release();
    }
}

场景三：retain/release不匹配

// 错误示例
ByteBuf buf = allocator.buffer(1024);
buf.retain();
buf.retain();
buf.release();  // refCnt = 2
// 泄漏！refCnt不为0

// 正确做法
ByteBuf buf = allocator.buffer(1024);
buf.retain();
buf.retain();
buf.release();  // refCnt = 2
buf.release();  // refCnt = 1
buf.release();  // refCnt = 0, 回收

七、ByteBuf的正确使用姿势

7.1 使用ByteBufAllocator

// 在Channel中获取Allocator
ByteBufAllocator allocator = ctx.alloc();

// 分配ByteBuf
ByteBuf buffer = allocator.buffer(1024);
ByteBuf directBuffer = allocator.directBuffer(1024);
ByteBuf heapBuffer = allocator.heapBuffer(1024);

// 使用完毕释放
buffer.release();

7.2 使用try-finally确保释放

public void processMessage(ChannelHandlerContext ctx, ByteBuf msg) {
    ByteBuf response = ctx.alloc().buffer(1024);
    try {
        // 构建响应
        response.writeInt(200);
        response.writeBytes("OK".getBytes());
        
        // 发送响应
        ctx.writeAndFlush(response);
        
        // 注意：writeAndFlush后response的引用被转移，不需要再release
    } catch (Exception e) {
        // 异常时释放
        response.release();
        throw e;
    }
}

7.3 使用ReferenceCountUtil工具类

import io.netty.util.ReferenceCountUtil;

public void channelRead(ChannelHandlerContext ctx, Object msg) {
    try {
        // 处理消息
        processMessage(msg);
    } finally {
        // 安全释放（检查是否为ReferenceCounted）
        ReferenceCountUtil.release(msg);
    }
}

// 安全retain
ReferenceCountUtil.retain(msg);

// 安全释放，带计数
ReferenceCountUtil.release(msg, 2);

7.4 派生缓冲区的使用

ByteBuf parent = ctx.alloc().buffer(1024);
parent.writeBytes("Hello World".getBytes());

// slice() - 共享底层内存，不增加引用计数
ByteBuf slice = parent.slice(0, 5);  // "Hello"
// slice和parent共享内存，修改slice会影响parent

// duplicate() - 共享整个缓冲区
ByteBuf duplicate = parent.duplicate();

// copy() - 深拷贝，独立内存
ByteBuf copy = parent.copy();  // 新分配内存

// 使用派生缓冲区时要注意引用计数
slice.retain();  // 需要手动retain
try {
    processSlice(slice);
} finally {
    slice.release();
    parent.release();
}

八、性能优化建议

8.1 预估容量避免扩容

// 错误示例：频繁扩容
ByteBuf buffer = ctx.alloc().buffer();  // 默认256字节
for (int i = 0; i < 1000; i++) {
    buffer.writeInt(i);  // 频繁扩容
}

// 正确做法：预估容量
ByteBuf buffer = ctx.alloc().buffer(4000);  // 1000个int = 4000字节
for (int i = 0; i < 1000; i++) {
    buffer.writeInt(i);  // 无需扩容
}

8.2 使用池化分配器

// 配置使用池化分配器
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
        .channel(NioServerSocketChannel.class)
        .option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
        .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);

8.3 减少内存拷贝

// 使用CompositeByteBuf合并多个缓冲区
ByteBuf header = ctx.alloc().buffer(10);
ByteBuf body = ctx.alloc().buffer(100);

// 错误做法：拷贝合并
ByteBuf combined = ctx.alloc().buffer(110);
combined.writeBytes(header);
combined.writeBytes(body);

// 正确做法：逻辑合并
CompositeByteBuf composite = ctx.alloc().compositeBuffer();
composite.addComponents(true, header, body);  // 无内存拷贝

九、总结

ByteBuf是Netty内存管理的核心：

1. 设计改进：双指针设计、动态扩容、丰富API
2. 内存类型：Heap适合业务处理，Direct适合网络传输
3. 内存池：PoolArena + ThreadLocal缓存，减少分配开销
4. 引用计数：retain/release机制，精确控制生命周期
5. 泄漏检测：多级别检测，帮助定位泄漏问题
6. 正确使用：try-finally释放、使用SimpleChannelInboundHandler

下一篇，我们将深入分析Netty的零拷贝技术实现。