JVM第五篇(直接内存)

直接内存 Direct Memory：
直接内存，并不属于JVM中的内存结构，直接内存，不由JVM进行管理。直接内存是属于系统内存。
直接内存

1. 常见于 NIO 操作时，用于数据缓冲区
2. 分配回收成本较高，但读写性能高
3. 不受 JVM 内存回收管理

在进行NIO操作，可以使用直接内存来作数据缓冲区，来提高读写效率。
下图是使用堆内存用于数据缓冲区的情况：

由于Java不能对系统内存直接进行操作，所以数据线先从磁盘文件读到系统内存中，再由系统内存，读入到Java堆内存中，效率比较低。

下图是使用了直接内存作为数据缓冲区的情况：

在系统中开辟了一块直接内存，作为数据缓冲区，先从磁盘将文件读入直接内存中，java可以对直接内存进行操作，就不需要再将数据读取到堆内存中，效率大大提高。

直接内存不受JVM的管理，直接内存的由操作系统直接进行管理。
在Java代码中通过 Unsafe类来对直接内存进行分配和释放。

 public native void freeMemory(long var1);
 public native long allocateMemory(long var1);

在java中可以使用
public abstract class ByteBuffer这个类间接的完成直接内存的分配和释放
通过ByteBuffer下的allocateDirect方法来进行直接内存的分配
下面是源码

public static ByteBuffer allocateDirect(int capacity) {
	return new DirectByteBuffer(capacity);
}
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;
}
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);    // 最终执行了 freeMemory方法，完成直接内存的释放
        address = 0;
        Bits.unreserveMemory(size, capacity);
    }
}

可以以上代码 完成了 直接内存的分配和释放。当Java中不在引用直接内存时，自动进行释放。
可以通过显示的 GC 来实现

public static void main(String[] args) throws IOException {
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb);
    System.out.println("分配完毕...");
    System.in.read();
    System.out.println("开始释放...");
    byteBuffer = null;
    System.gc(); // 显式的垃圾回收，Full GC
    System.in.read();
}

通过ByteBuffer类分配了直接内存，然后不在引用直接内存，显示调用gc方法，进行垃圾回收，将byteBuffer内存进行回收，从而触发Deallocator类中run方法，将直接内存进行回收。

System.gc(); // 显式的垃圾回收，Full GC
显示的垃圾回收，是Full GC，比较影响性能，所以也可以直接在程序中调用 freeMemory 方法，进行直接内存的释放。