关于DirectByteBuffer直接堆外内存释放的理解

基本概念：

JVM可以使用的内存分外2种：堆内存和堆外内存，堆内存完全由JVM负责分配和释放，如果程序没有缺陷代码导致内存泄露，那么就不会遇到java.lang.OutOfMemoryError这个错误。使用堆外内存，就是为了能直接分配和释放内存，提高效率。

我的理解：

Unsafe.allocateMemory分配堆外内存，Unsafe.freeMemory释放堆外内存，分配内存通过ByteBuffer.allocateDirect创建DirectByteBuffer对象并分配内存，同时记录相关分配大小并创建回调函数Cleaner，记录堆外内存分配大小的目的在于便于下一次分配的时候判断内存是否够用，不够用了调用gc，但是gc只负责jvm内存回收，那是如何回收堆外内存的呢，答案是：创建回调函数的目的是gc调用之后，会调用DirectByteBuffer的回调对象Cleaner的clean（）方法，进行内存回收，同时减去已使用堆外内存的大小

举例分析

场景：设置虚拟机堆大小等于40M，并打印相关GC信息（idea Vm optinos设置： -verbose:gc -XX:+PrintGCDetails -XX:MaxDirectMemorySize=40M），每次分配10M大小，启动，并跟踪代码：

public static void main(String[] args) {
    while (true) {
        ByteBuffer.allocateDirect(10 * 1024 * 1024);
    }
}

创建DirectByteBuffer对象

public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
    }

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));
// 记录使用大小，判断申请分配的堆外内存是否大于剩余堆外内存，如果大于将会调用gc，之后分析
        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)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
// 虚引用PhantomReference， 在<<深入理解Java虚拟机>>一文中，
// 它唯一的目的就是为一个对象设置虚引用关联的唯一目的就是能在这
// 个对象被收集器回收时收到一个系统通知，Cleaner就是一个继承了PhantomReference，
// 作为一个回调的钩子调用，最终当堆外内存不够用当时候，而第二个参数Deallocator是一个继承
// Thread的线程类，当调用Cleaner的clean（）方法的时候，会执行Deallocator线程调用
// unsafe.freeMemory释放堆外内存
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;

    }

        Bits.reserveMemory(size, cap);判断堆外内存使用情况：

static void reserveMemory(long size, int cap) {

        // 省略
        // 判断堆外内存使用情况
        if (tryReserveMemory(size, cap)) {
            return;
        }
        // 回调函数的引用（Cleaner类）
        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
        // 堆外内存不够用了执行gc，之后会调用回调函数clean（），进行堆外内存回收
        System.gc();

         // 省略
        try {
            long sleepTime = 1;
            int sleeps = 0;
            while (true) {
                // 尝试对堆外内存的分配进行判断，直到满足分配情况，停止循环
                if (tryReserveMemory(size, cap)) {
                    return;
                }
                if (sleeps >= MAX_SLEEPS) {
                    break;
                }
                // 在这里调用会调用到引用clean()方法
                if (!jlra.tryHandlePendingReference()) {
                    try {
                        Thread.sleep(sleepTime);
                        sleepTime <<= 1;
                        sleeps++;
                    } catch (InterruptedException e) {
                        interrupted = true;
                    }
                }
            }

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

    }

判断堆外内存分配情况如下图，可以看到我们设置到堆外内存总大小maxMemory=41943040（40M），每次申请大小size=10M，已用大小totalCap=20M（循环了两次），如果堆外内存不够用了返回true，reserveMemory将执行System.gc()

接下来分析堆外内存不够用之后，是否调用了回调函数clean（），答案是肯定的，会调用的

 public void run() {
            if (address == 0) {
                // Paranoia
                return;
            }
            unsafe.freeMemory(address);
            address = 0;
            Bits.unreserveMemory(size, capacity);
        }

认真写写博客，写写生活点滴