JVM直接内存（七）

1、Direct Mermory:

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

2、Direct Mermory对写性能高的原因？

由于Java不能直接取系统的文件的。当执行文件读取时java会调动本地的native方法，切换的到本地系统的内核态，内核会调用本地系统的函数，开辟一块缓存区域，这块缓冲区就叫直接内存，同时Java也会在虚拟机堆内存中开辟一块Java 缓冲区 ，由于java是不可以读取本地缓存区的，所以它需要将本地缓存区的数据copy到java缓冲区，然后再去调动IO 输出流，如此反复操作（如下图一）。传统IO慢的原因就是在缓存区copy过程。
而NIO之所以快的原因是没有了copy的过程，本地开辟的缓存区java是直接可以访问的，它是通过一个ByteBuffer.allocateDirect（）的方法开辟的（图二）

图一

图二
下面是两种IO运行比较

static final String FROM = "读取文件";
static final String TO = "目标文件";
static final int _1Mb = 1024 * 1024;

public static void main(String[] args) {
    io(); // io 用时：1535.586957 1766.963399 1359.240226
    directBuffer(); // directBuffer 用时：479.295165 702.291454 562.56592
}

private static void directBuffer() {
    long start = System.nanoTime();
    try (FileChannel from = new FileInputStream(FROM).getChannel();
         FileChannel to = new FileOutputStream(TO).getChannel();
    ) {
        ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
        while (true) {
            int len = from.read(bb);
            if (len == -1) {
                break;
            }
            bb.flip();
            to.write(bb);
            bb.clear();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    long end = System.nanoTime();
    System.out.println("directBuffer 用时：" + (end - start) / 1000_000.0);
}

private static void io() {
    long start = System.nanoTime();
    try (FileInputStream from = new FileInputStream(FROM);
         FileOutputStream to = new FileOutputStream(TO);
    ) {
        byte[] buf = new byte[_1Mb];
        while (true) {
            int len = from.read(buf);
            if (len == -1) {
                break;
            }
            to.write(buf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    long end = System.nanoTime();
    System.out.println("io 用时：" + (end - start) / 1000_000.0);
}

3、直接内存溢出的问题演示

public class DriectMemoryOut {
	 static int _100Mb = 1024 * 1024 * 100;

	    public static void main(String[] args) {
	        List<ByteBuffer> list = new ArrayList<>();
	        int i = 0;
	        try {
	            while (true) {
	                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
	                list.add(byteBuffer);
	                i++;
	            }
	        } finally {
	            System.out.println(i);
	        }
	        // 方法区是jvm规范， jdk6 中对方法区的实现称为永久代
	        //                  jdk8 对方法区的实现称为元空间
	    }
}

运行结果：

Exception in thread "main" 27
java.lang.OutOfMemoryError: Direct buffer memory
	at java.nio.Bits.reserveMemory(Bits.java:694)
	at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
	at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
	at com.it.DriectMemoryOut.main(DriectMemoryOut.java:15)

4、显示内存释放

/**
 * 禁用显式回收对直接内存的影响
 */
public class Demo1_26 {
    static int _1Gb = 1024 * 1024 * 1024;

    /*
     * -XX:+DisableExplicitGC 显式的
     */
    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();
    }
}

5、直接内存分配的底层原理

```handlebars
/**
 * 直接内存分配的底层原理：Unsafe
 */
public class Demo1_27 {
    static int _1Gb = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();
        // 分配内存
        long base = unsafe.allocateMemory(_1Gb);
        unsafe.setMemory(base, _1Gb, (byte) 0);
        System.in.read();

        // 释放内存
        unsafe.freeMemory(base);
        System.in.read();
    }

    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            Unsafe unsafe = (Unsafe) f.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}