Netty学习十：内存管理之Netty堆外内存

一、堆外内存

在Java中，对象基本上都是在堆内分配的，我们所说的JVM内存就是指的堆内内存，堆内内存完全由JVM虚拟机所管理，JVM利用垃圾回收算法进行堆内内存的回收，使用者不需要关心对象的内存如何回收。

堆外内存与堆内内存相对，对于整个机器内存而言，除了堆内存以外的部分就是堆外内存。堆外内存不受JVM管理，直接由操作系统进行管理。

堆外内存和堆内内存的对比：

• 堆内内存由JVM GC自动回收管理，但是GC需要时间开销成本；堆外内存不受JVM管理，一定程度上可以降低GC对应用运行带来的影响。
• 堆外内存需要手动释放，稍有不慎会造成应用程序内存泄漏，当出现内存泄漏时问题排查相对困难。
• 当进行网络I/O操作、文件读写时，堆内内存需要转换为堆外内存，然后再与底层设备进行交互。直接使用堆外内存可以减少一次内存拷贝。
• 堆外内存可以进行进程之间、JVM多实例之间的数据共享。

二、堆外内存的分配

1. ByteBuffer.allocateDirect()

使用方式如下：

// 分配 10M 堆外内存
ByteBuffer buffer = ByteBuffer.allocateDirect(10 * 1024 * 1024); 

跟进allocateDirect方法，其中直接调用DirectByteBuffer构造函数

DirectByteBuffer(int cap) {
    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    Bits.reserveMemory(size, cap);
    long base = 0;
    try {
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

上述的初始化过程，可以参考以下示意图。堆内存放的DirectByteBuffer对象并不大，仅包含堆外内存的地址、大小等属性。同时，DirectByteBuffer中还会创建Cleaner对象，通过ByteBuffer分配的堆外内存不需要手动回收。当DirectByteBuffer对象被GC回收时，Cleaner就会回收对应的堆外内存。

在DirectByteBuffer的构造函数中，实际的堆外内存分配逻辑还是通过Unsafe.allocateMemory()方法实现。

2. Unsafe.allocateMemory()

Unsafe是一个非常不安全的类，它用于执行内存访问、分配、修改等敏感操作，可以越过JVM限制的枷锁。Unsafe最初并不是为了开发者设计的，使用它虽然可以获取对底层资源的控制权，但是也失去了安全性的保证。

Java中不能直接使用Unsafe，需要通过反射获取到Unsafe实例，使用方式如下：

private static Unsafe unsafe = null;
static {
    try {
        Field getUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        getUnsafe.setAccessible(true);
        unsafe = (Unsafe) getUnsafe.get(null);
    } catch (NoSuchFieldException | IllegalAccessException e) {
        e.printStackTrace();
    }
}

获取Unsafe实例后，通过allocateMemory()方法分配堆外内存，方法返回内存地址：

// 分配 10M 堆外内存
long address = unsafe.allocateMemory(10 * 1024 * 1024);

不同于ByteBuffer，Unsafe分配的堆外内存需要手动释放，否则会造成内存释放：

unsafe.freeMemory(address);

三、堆外内存的回收

虽然当DirectByteBuffer对象被GC回收时，Cleaner就会回收对应的堆外内存。但是如果DirectByteBuffer对象长时间存活于堆内存中，可能会晋升到老年代，此时需要依赖Old GC或者Full GC才能触发清理。如果长时间没有Old GC或者Full GC执行，即使堆外内存不再使用，也无法释放，导致物理内存耗尽。

如何避免这种情况呢？上述情况是因为JVM不知道堆外内存已经不足，因此通过JVM参数-XX:MaxDirectMemorySize指定堆外内存的上限。当堆外内存达到上限，就会触发一次Full GC进行清理，如果Full GC之后还是无法满足堆外内存的分配，就会抛出OOM异常。

同时，ByteBuffer.allocateDirect()在分配堆外内存的过程中，如果没有足够空间分配堆外内存，在Bits.reverseMemory方法也会主动调用System.gc()强制Full GC。但是生产环境一般设置了-XX:+DisableExplicitGC，System.gc()不起作用，因此不能过分依赖System.gc()。

当通过GC的方法对DirectByteBuffer对象进行回收后，堆外内存是如何被释放的呢？这里就要借助DirectByteBuffer初始化时创建的Cleaner对象，由该对象进行堆外内存的回收。那么具体是怎么回收的呢？

Java中对象的引用分为四种：强引用StrongReference、软引用SoftReference、弱引用WeakReference和虚引用PhantomReference。Cleaner就属于PhantomReference的子类，PhantomReference不能被单独使用，需要与引用队列ReferenceQueue联合使用

public class Cleaner extends java.lang.ref.PhantomReference<java.lang.Object> {
    private static final java.lang.ref.ReferenceQueue<java.lang.Object> dummyQueue;
    private static sun.misc.Cleaner first;
    private sun.misc.Cleaner next;
    private sun.misc.Cleaner prev;
    private final java.lang.Runnable thunk;
    public void clean() {}
}

当初始化内存时，内存中的对象引用情况如下图所示。first是Cleaner类的静态变量，Cleaner在初始化时会加入Cleaner链表。DirectByteBuffer对象包含堆外内存的大小、地址以及Cleaner的引用，ReferenceQueue用于回收Cleaner。

当GC发生时，DirectByteBuffer对象被回收，Cleaner不再有任何引用关系，在下一次GC时，Cleaner对象会被加入ReferenceQueue中，并执行cleans()方法。cleans()方法主要做两件事：

• 将Cleaner对象从Cleaner链表中移除
• 调用unsafe.freeMemory()方法清理对外内存