虚引用与堆外内存研究(基于DirectByteBuffer源码)

(1)堆内存
ByteBuffer buffer = ByteBuffer.allocate(1024);
字节数组保存数据HeapByteBuffer
   
(2)堆外内存
ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(1024);
Buffer类有个：long address;用于保存堆外空间地址
unsafe来分配以及最后回收空间
构建Cleaner对象，继承虚引用，将当前堆外内存以及垃圾清理线程对象传递过去，GC发生后，调用Deallocator的clean方法，内部有调用unsafe来回收堆外内存。

DirectByteBuffer(int cap) {              
        //** address，base分配堆外内存空间之后的起始地址
        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对象用于跟踪DirectByteBuffer对象的垃圾回收，以实现当DirectByteBuffer被垃圾回收时，堆外内存也会被释放
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        //********************************
}
/**
**继承虚引用
* clener回收列表：其中first是Cleaner类的静态变量，Cleaner对象在初始化时会被添加到Clener链表中， * 和first形成引用关系，。
* ReferenceQueue是用来保存需要回收的Cleaner对象。
* cleaner对象唯一保存了堆外内存的数据（开始地址、大小和容量）
* 若DerectByteBuffer对象被回收，那么把它内部的Cleaner对象放入到ReferenceQueue中，并触发clean * 方法。释放堆外内存。
*/
public class Cleaner extends PhantomReference<Object> {
    private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue();
    private static Cleaner first = null;
    private Cleaner next = null;
    private Cleaner prev = null;
    private final Runnable thunk;
    
    // var1 即directBuffer, var2即runnable对象Deallocator对象
    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) {
             ***   
            }
        }
    }
}
// 回收线程，保存堆外内存信息以及执行回收操作
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) {
                return;
            }
            unsafe.freeMemory(address);
            address = 0;
            Bits.unreserveMemory(size, capacity);
        }
}