堆外内存释放

结论：堆外内存只有在fullgc的时候才能够回收掉。

构造函数：主要看三个地方，一个是Bits.reserverMemory  一个是unsafe.allocateMemory 一个是 Cleaner.create。Bits主要是记录了堆外内存的使用情况和最大容量。

   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)) {
            // 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;
    }

1.1.1：reserveMemory分配内存，主要逻辑在tryReserveMemory里面，如果分配失败了，会尝试回收内存再分配，还失败就调用System.gc，然后再分配，如果还是失败就会抛出异常

    static void reserveMemory(long size, int cap) {

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

        // 如果能够分配
        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
        // 如果还是失败，触发gc(只是建议jvm gc)
        System.gc();

        // a retry loop with exponential back-off delays
        // (this gives VM some time to do it's job)
        //  循环几次 休息1ms(让出cpu 等待jvm gc)，尝试分配，尝试10次后报错
        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();
            }
        }
    }

1.1.2：tryReserveMemory具体的逻辑，就Bits不是实际分配内存的地方，它只是比较一下容量有没有超过设置的最大容量。

  private static boolean tryReserveMemory(long size, int cap) {

        // -XX:MaxDirectMemorySize limits the total capacity rather than the
        // actual memory usage, which will differ when buffers are page
        // aligned.
        long totalCap;
        // 看看有没有超过最大容量 这里没有根据实际的内存做判断
        // 也就是说你把-XX:MaxDirectMemorySize设置的很大，不会触发gc
        // 后面系统实际分配不了会抛oom
        while (cap <= maxMemory - (totalCap = totalCapacity.get())) {
            if (totalCapacity.compareAndSet(totalCap, totalCap + cap)) {
                reservedMemory.addAndGet(size);
                count.incrementAndGet();
                return true;
            }
        }

        return false;
    }

1.2.1：unsafe.allocateMemory，这是一个本地方法，负责实际的分配内存。如果实际内存不够分配，会抛出异常。

1.3.1：Cleaner.create。这个是创建一个cleaner对象，这是一个虚引用，指向了DirectByteBuffer对象本身。在DirectByteBuffe对象被回收时，这个cleaner对象会被jvm加入到引用队列，jvm会有专门的线程（Reference类的静态块起了一个线程，用来不停的清理引用队列。）处理这个队列，如果发现是cleaner对象，就会调用cleaner.clean。而在cleaner构建的时候绑定了一个清理任务。最后调用的是unsafe.freeMemory(address)释放内存，这也是一个本地方法。

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;
    // 绑定的runable
    private final Runnable thunk;

    private static synchronized Cleaner add(Cleaner var0) {
        if (first != null) {
            var0.next = first;
            first.prev = var0;
        }

        first = var0;
        return var0;
    }

    private static synchronized boolean remove(Cleaner var0) {
        if (var0.next == var0) {
            return false;
        } else {
            if (first == var0) {
                if (var0.next != null) {
                    first = var0.next;
                } else {
                    first = var0.prev;
                }
            }

            if (var0.next != null) {
                var0.next.prev = var0.prev;
            }

            if (var0.prev != null) {
                var0.prev.next = var0.next;
            }

            var0.next = var0;
            var0.prev = var0;
            return true;
        }
    }

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

    public static Cleaner create(Object var0, Runnable var1) {
        // 调用add 加入列表，绑定了一个清理器
        return var1 == null ? null : add(new Cleaner(var0, var1));
    }

    public void clean() { // clean方法就是调用绑定的runnable.run
        if (remove(this)) {
            try {
                this.thunk.run();
            } catch (final Throwable var2) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        if (System.err != null) {
                            (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
                        }

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

        }
    }
}

最后看一下如何处理引用队列。（当对象被回收时，如果含有虚引用就会把虚引用加入pending）

   static boolean tryHandlePending(boolean var0) {
        Reference var1;
        Cleaner var2;
        try {
            synchronized(lock) {
                if (pending == null) {
                    if (var0) {
                        lock.wait();
                    }

                    return var0;
                }
                // jvm回收时，会把虚引用放入pending
                var1 = pending;
                // 判断是不是cleaner类型
                var2 = var1 instanceof Cleaner ? (Cleaner)var1 : null;
                pending = var1.discovered;
                var1.discovered = null;
            }
        } catch (OutOfMemoryError var6) {
            Thread.yield();
            return true;
        } catch (InterruptedException var7) {
            return true;
        }
        // 如果是cleaner类型 调用clean方法
        if (var2 != null) {
            var2.clean();
            return true;
        } else {
            ReferenceQueue var3 = var1.queue;
            if (var3 != ReferenceQueue.NULL) {
                var3.enqueue(var1);
            }

            return true;
        }
    }

总结：