Java堆外内存DirectByteBuffer 回收原理

DirectByteBuffer简介

DirectByteBuffer这个类是JDK提供使用堆外内存的一种途径，当然常见的应用一般不会接触到，即使涉及到也可能是框架（如netty、rpc等）使用的，对框架使用者来说也是透明的。

DirectByteBuffer作用

堆外内存优势在于IO操作上，能够节省堆内存到堆外内存的拷贝，所以性能更高，看过netty源码的同学应该了解；另外磁盘IO时，可以使用内存映射，提升性能；而且没有类似堆内存烦人的GC。

DirectByteBuffer创建

 // Primary constructor
    //
    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);

        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;
        }
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;

    }

直接上代码，首先向Bits类申请额度，Bits类内部维护着当前已经使用的堆外内存值，会check是当前申请的大小与已经使用的内存大小是否超过总的堆外内存大小（默认大小与堆内存一样），可以使用 -XX:MaxDirectMemorySize 重新设置。
如果check不通过，会主动执行System.gc()，然后sleep 100ms，最多重试9次，再进行check，如果内存还是不足，就抛出OOM Error。

如果check通过，就会调用unsafe.allocateMemory真正分配内存，返回内存地址，然后再将内存清0。题外话，这个unsafe命名看着是不是很吓人，这个unsafe不是说不安全，而是jdk内部使用的内，不推荐外部使用，所以叫unsafe，netty内部源码也有类似命名。
由于申请内存前可能会调用System.gc()，所以谨慎设置-XX:+DisableExplicitGC这个选项，这个参数作用是禁止代码中显示调用GC。

DirectByteBuffer回收

cleaner = Cleaner.create(this, new Deallocator(base, size, cap));

看到这段代码从成员的命名上就应该知道，是用来回收堆外内存的，确实，但是它是如何工作的呢？接下来我们看看Cleaner类。

public class Cleaner extends PhantomReference {
    private static final ReferenceQueue dummyQueue = new ReferenceQueue();
    private static Cleaner first = null;
    private Cleaner next = null;
    private Cleaner prev = null;
    private final Runnable thunk;

    private static synchronized Cleaner add(Cleaner var0) {
       ...
    }

    private static synchronized boolean remove(Cleaner var0) {
        ...
    }

    private Cleaner(Object var1, Runnable var2) {
        super(var1, dummyQueue);
        this.thunk = var2;
    }

    public static Cleaner create(Object var0, Runnable var1) {
        return var1 == null?null:add(new Cleaner(var0, var1));
    }

    public void clean() {
        if(remove(this)) {
            try {
                this.thunk.run();
            } catch (final Throwable var2) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        if(System.err != null) {
                            (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
                        }

                        System.exit(1);
                        return null;
                    }
                });
            }

        }
    }
}

Cleaner类，内部维护了一个Cleaner对象的双向链表，通过create(Object, Runnable)方法创建cleaner对象，调用自身的add方法，将其加入到链表中。
更重要的是提供了clean方法，clean方法首先将对象自身从链表中删除，保证只调用一次，然后执行this.thunk的run方法，thunk就是由创建时传入的Runnable参数，也就是说clean只负责触发Runnable的run方法，至于Runnable做什么任务它不关心。那DirectByteBuffer传进来的Runnable是什么呢？

 private static class Deallocator
        implements Runnable
    {

        private static Unsafe unsafe = Unsafe.getUnsafe();

        private long address;
        private long size;
        private int capacity;

        private Deallocator(long address, long size, int capacity) {
            assert (address != 0);
            this.address = address;
            this.size = size;
            this.capacity = capacity;
        }

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

    }

Deallocator类的对象就是DirectByteBuffer中的cleaner传进来的Runnable参数类，我们直接看run方法unsafe.freeMemory释放内存，然后更新Bits里已使用的内存数据。接下来我们关注各个环节是如何串起来的？

自动回收

自动回收，当然由GC负责回收的，在GC时会扫描DirectByteBuffer对象是否有影响GC的引用，如没有，在回收DirectByteBuffer对象的同时且会回收其占用的堆外内存。但是JVM如何释放其占用的堆外内存呢？如何跟Cleaner关联起来呢？

这得从Cleaner继承了PhantomReference引用说起。说到Reference，还有SoftReference、WeakReference、FinalReference他们作用各不相同，这里就不展开说了。
简单介绍PhantomReference（虚引用），首先虚引用不会影响JVM是否要GC这个对象的判断，当GC某个对象时，如果有此对象上还有虚引用，会将PhantomReference对象插入ReferenceQueue队列。

PhantomReference插入到哪个队列呢？
看PhantomReference类代码，其继承自Reference，Reference对象有个ReferenceQueue成员，这个也就是PhantomReference对象插入的ReferenceQueue队列，此成员如果不由外部传入就是ReferenceQueue.NULL。如果需要通过queue拿到PhantomReference对象，这个ReferenceQueue对象还是必须由外部传入。

private static final ReferenceQueue dummyQueue = new ReferenceQueue();

private Cleaner(Object var1, Runnable var2) {
        super(var1, dummyQueue);
        this.thunk = var2;
}

public class PhantomReference extends Reference {

Reference 类内部static静态块会启动ReferenceHandler线程，线程优先级很高，这个线程是用来处理JVM在gc过程中交接过来的reference，并做一些处理。想必经常用jstack命令，看线程堆栈的同学应该见到过这个线程。

public abstract class Reference {

   
    private T referent;         /* Treated specially by GC */

    ReferenceQueue queue;

    Reference next;
    transient private Reference discovered;  /* used by VM */

    static private class Lock { };
    private static Lock lock = new Lock();
    private static Reference pending = null;
    
    ...

    static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
        /* If there were a special system-only priority greater than
         * MAX_PRIORITY, it would be used here
         */
        handler.setPriority(Thread.MAX_PRIORITY);
        handler.setDaemon(true);
        handler.start();
    }

    public T get() {
        return this.referent;
    }

    public void clear() {
        this.referent = null;
    }

    public boolean isEnqueued() {
            synchronized (this) {
            return (this.queue != ReferenceQueue.NULL) && (this.next != null);
        }
    }

  
    public boolean enqueue() {
        return this.queue.enqueue(this);
    }


    /* -- Constructors -- */

    Reference(T referent) {
        this(referent, null);
    }

    Reference(T referent, ReferenceQueue queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }

}

我们来看看ReferenceHandler是如何处理的？直接看run方法，首先是个死循环，一直在那不停的干活，synchronized块内的这段主要是交接JVM扔过来的reference（就是pending），再往下看，很明显，调用了cleaner的clean方法。调完之后直接continue结束此次循环，这个reference并没有进入queue，也就是说Cleaner虚引用是不放入ReferenceQueue。

/* High-priority thread to enqueue pending References
     */
    private static class ReferenceHandler extends Thread {

        ReferenceHandler(ThreadGroup g, String name) {
            super(g, name);
        }

        public void run() {
            for (;;) {

                Reference r;
                synchronized (lock) {
                    if (pending != null) {
                        r = pending;
                        Reference rn = r.next;
                        pending = (rn == r) ? null : rn;
                        r.next = r;
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException x) { }
                        continue;
                    }
                }

                // Fast path for cleaners
                if (r instanceof Cleaner) {
                    ((Cleaner)r).clean();
                    continue;
                }

                ReferenceQueue q = r.queue;
                if (q != ReferenceQueue.NULL) q.enqueue(r);
            }
        }
    }

这块有点想不通，既然不放入ReferenceQueue，为什么Cleaner类还是初始化了这个ReferenceQueue。

手动回收

手动回收，就是由开发手动调用DirectByteBuffer的cleaner的clean方法来释放空间。由于cleaner是private反问权限，所以自然想到使用反射来实现。

public static void clean(final ByteBuffer byteBuffer) {  
 if (byteBuffer.isDirect()) { 
        Field cleanerField = byteBuffer.getClass().getDeclaredField("cleaner");
        cleanerField.setAccessible(true);
        Cleaner cleaner = (Cleaner) cleanerField.get(byteBuffer);
        cleaner.clean();
    }
}

还有另一种方法，DirectByteBuffer实现了DirectBuffer接口，这个接口有cleaner方法可以获取cleaner对象。

public static void clean(final ByteBuffer byteBuffer) {  
    if (byteBuffer.isDirect()) {  
        ((DirectBuffer)byteBuffer).cleaner().clean();  
    }  
}

原文地址：https://www.jianshu.com/p/8e942cd7b572?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation