堆外内存总结

前言

　　上次网易一面面试官提到了“是否了解堆外内存？”、“堆外内存是否需要手动释放？”等问题，那时候我误以为所提到的“堆外内存”是指元空间这个jvm管理的堆外内存，对于元空间是否手动释放这样的问题就令我十分疑惑，按理说当元空间的类信息会在类被定义成“无用的类”时会被回收，因此不需要我们手动释放，然后面试小哥又重复了一遍我的回答“不需要手动释放吗？”，我只能回答对此可能不是很了解。

　　面试结束后上网搜索了一下，他想要问的应该是java中的DirectByteBuffer，而今天早上又看到一篇博客“堆外内存泄漏的排查过程”。就打算今天对堆外内存做一个总结。

使用

　　DirectByteBuffer的创建非常简单，使用ByteBuffer的静态方法

    ByteBuffer dirBuf = ByteBuffer.allocateDirect(capacity);

　　就可以创建一个DirectByteBuffer，与普通的ByteBuffer不一样的地方在于一个是在jvm堆内存中，另一个不在jvm堆内存中。

创建、清理

　　为了了解堆外内存是如何被回收的，我们先来看allocateDirect这个方法是如何创建一个实例的。

    DirectByteBuffer(int cap) {                   // package-private

        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);//1.1预定一块空间

        long base = 0;
        try {
            base = unsafe.allocateMemory(size);//1.2创建
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));//2.构造一个Cleaner对象
        att = null;

    }

　　先进入（注释1.1）Bits.reserveMemory(size, cap)这个方法，它主要是预申请一块空间，size是系统的页大小。

    static void reserveMemory(long size, int cap) {

        if (!memoryLimitSet && VM.isBooted()) {
            maxMemory = VM.maxDirectMemory();
            memoryLimitSet = true;
        }

        // optimist!
        if (tryReserveMemory(size, cap)) {
            return;
        }

        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();

        // retry while helping enqueue pending Reference objects
        // which includes executing pending Cleaner(s) which includes
        // Cleaner(s) that free direct buffer memory
        while (jlra.tryHandlePendingReference()) {
            if (tryReserveMemory(size, cap)) {
                return;
            }
        }

        // trigger VM's Reference processing
        System.gc();

        // a retry loop with exponential back-off delays
        // (this gives VM some time to do it's job)
        boolean interrupted = false;
        try {
            long sleepTime = 1;
            int sleeps = 0;
            while (true) {
                if (tryReserveMemory(size, cap)) {
                    return;
                }
                if (sleeps >= MAX_SLEEPS) {
                    break;
                }
                if (!jlra.tryHandlePendingReference()) {
                    try {
                        Thread.sleep(sleepTime);
                        sleepTime <<= 1;
                        sleeps++;
                    } catch (InterruptedException e) {
                        interrupted = true;
                    }
                }
            }

            // no luck
            throw new OutOfMemoryError("Direct buffer memory");

        } finally {
            if (interrupted) {
                // don't swallow interrupts
                Thread.currentThread().interrupt();
            }
        }
    }

　　reserveMemory方法流程：

　　1、首先是第八行的tryReserveMemory方法，尝试申请空间

　　2、申请失败就到第18-22行尝试清理堆外内存，再tryReserveMemory

　　3、如果清理完了还是申请失败，就调用System.gc()，触发full gc，触发后，可以清理老年代（新生代也可能有但是大多是在老年代的）的堆外内存的引用（如果存在应该被清理的引用），清理完后就是剩下的部分，33-53行自旋MAX_SLEEPS次，sleep等待full gc的触发（System.gc()可能有延时），如果次数大于MAX_SLEEPS还没申请成功，就抛出异常。

　　

　　接下来是（注释1.2）的unsafe.allocateMemory真正创建堆外内存空间。

　　再之后是（注释2）创建Cleaner对象，用于之后清理这块堆外内存空间。

　　Cleaner继承PhantomReference类，并通过自身的next和prev字段维护的一个双向链表，当DirectByteBuffer对象从“pending” 变为 “enqueue”时（即gc过程中对象只有被虚引用，这个引用会被放到java.lang.ref.Reference.pending队列里，调用ReferenceHandler的run中不断自旋的tryHandlePending(true)方法处理，清理pending链，使用clean方法将堆外内存清理掉）。

参数设置

　　我们可以通过-XX:MaxDirectMemorySize来指定最大的堆外内存大小，当使用达到了阈值的时候将调用System.gc()来做一次full gc，以此来回收掉没有被使用的堆外内存，这个是jvm底层帮我们做的，我们只需要设定其参数即可。

使用情景

　　1、直接的文件拷贝操作，或者I/O操作。当操作系统对堆内内存进行文件拷贝、io处理时先会拷贝一份到堆外，再进行发送处理，而堆外内存就少了一个拷贝的耗时。

　　2、堆外内存适用于生命周期较长的对象，不会占用堆内的内存，这点与元空间的出现原因类似，Class信息一般生命周期也都较长。