Java堆外内存及调优方式

public static void main(String[] args) {
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
    // ...
}

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));
    // 尝试保留size大小的内存, 如果内存不够, 处理pending链表上的引用
    // 内存仍然不足，则显式GC, 将不可达的引用放入pending链表中, 再从pending回收内存
    // 内存不够, 则抛出OOM错误
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        // base为直接内存的基址
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    // 将分配到的直接内存每一个Byte设置为0
    unsafe.setMemory(base, size, (byte) 0);
    // 如果需要直接内存对齐, 且基址base不整除pageSize, 则调整起始地址为base+pageSize减去base%pageSize
    if (pa && (base % ps != 0)) {
        // address为ByteBuffer缓冲区可使用部分的起始地址
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    // CLeaner 持有 DirectByteBuffer 的幻影(虚)引用
    // Deallocator实现Runnable接口, 执行释放直接内存的操作
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

public class Cleaner extends PhantomReference<Object> {
    ...
    // Cleaner.create: var1传入DirectByteBuffer引用, var2传入Deallocator实例
    private Cleaner(Object var1, Runnable var2) {
        super(var1, dummyQueue);// DirectByteBuffer作为虚引用
        this.thunk = var2; // 
    }
    public static Cleaner create(Object var0, Runnable var1) {
        return var1 == null ? null : add(new Cleaner(var0, var1));
    }
}

public void run() {
    while (true) {
        tryHandlePending(true);
    }
}

static boolean tryHandlePending(boolean waitForNotify) {
    Reference<Object> r;
    Cleaner c;
    try {
        synchronized (lock) {
            if (pending != null) {
                r = pending;
                // Cleaner继承了虚引用, 需要调用clean方法, 因此特判。
                c = r instanceof Cleaner ? (Cleaner) r : null;
                // pending头节点更新为r的下一个节点
                pending = r.discovered;
                r.discovered = null;
            } else {
                // pending链表中元素为空, wait-notify等待唤醒
                if (waitForNotify) {
                    lock.wait();
                }
                // retry if waited
                return waitForNotify;
            }
        }
    }// ...
    // 如果Reference类型为Cleaner, 需要调用clean方法, 直接内存此时会被回收
    if (c != null) {
        c.clean();
        return true;
    }
    // 将Reference实例加入到引用队列中
    ReferenceQueue<? super Object> q = r.queue;
    // 注册了引用队列, 则入队, 入队后修改r.queue = ReferenceQueue.ENQUEUED, next指向队列中的后继
    if (q != ReferenceQueue.NULL) q.enqueue(r);
    return true;
}

// Cleaner
public void clean() {
    if (remove(this)) {
        try {
            this.thunk.run(); // thunk为Deallocator实例
        } // catch
    }
}

// private static class Deallocator implements Runnable
public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    // 释放直接内存, address为直接内存基址
    unsafe.freeMemory(address);
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
// theUnsafe为static final字段
Unsafe unsafe = (Unsafe) theUnsafe.get(null);
// 分配直接内存
long address = unsafe.allocateMemory(1024);
unsafe.freeMemory(address);

-XX:NativeMemoryTracking={summary|detail}

// 打印NMT信息
jcmd <pid> VM.native_memory detail

// 进行baseline，以对比分配内存变化
jcmd <pid> VM.native_memory baseline

// 对比baseline, 显示出各个部分内存的变化
jcmd <pid> VM.native_memory detail.diff

public class DirectMemory {
    public static void main(String[] args) {
        try {
            Thread.sleep(40000);// 进行baseline, 作为比对的参照
            System.out.println("Begin allocate: ...");
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * 3);    
            Thread.sleep(40000);    
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}