JVM详解（七）——直接内存

一、概述

1、介绍

　　直接内存，不是虚拟机运行时数据区的一部分，也不是《Java虚拟机规范》中定义的内存区域。是Java堆直接向系统申请的内存区间。
　　来源于NIO，通过存在堆中的DirectByteBuffer操作Native内存。通常，访问直接内存的速度会优于Java堆，即读写性能高。因此处于性能考虑，读写频繁的场合可能会考虑使用直接内存。Java的NIO库允许Java程序使用直接内存，用于数据缓冲区。

IO	NIO
byte[] / char[]	Buffer
面向流（Stream）	面向缓冲区（Channel）
阻塞	非阻塞

　　代码示例：IO与NIO、查看直接内存的占用与释放

public class BufferTest {
    // 1GB
    private static final int BUFFER = 1024 * 1024 * 1024;

    public static void main(String[] args) {
        // 直接分配本地内存空间
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
        System.out.println("直接内存分配完毕，请求指示！");

        Scanner scanner = new Scanner(System.in);
        scanner.next();

        System.out.println("直接内存开始释放！");
        byteBuffer = null;
        
        System.gc();
        scanner.next();
    }
}

　　通过任务管理器，以及进程id，都可以看到java.exe占用了1G的内存。

2、使用本地内存读写

　　通常，访问直接内存的速度会优于Java堆，即读写性能高。
　　读写文件，需要与磁盘交互，需要由用户态切换到内核态，在内核态时，需要内存如图的操作。使用IO，如图，这里需要两份内存存储重复数据，效率低。非直接缓冲区：

　　使用NIO，如图，操作系统划出的直接缓存区可以被Java代码直接访问，只有一份，NIO适合对大文件的读写操作。直接缓冲区：

　　代码示例：使用本地内存读写数据的测试，验证直接缓冲区的读写性能比IO高。

public class BufferTest1 {

    private static final int _100Mb = 1024 * 1024 * 100;

    public static void main(String[] args) {
        long sum = 0;

        String src = "F:\\后会无期.mkv";

        for (int i = 0; i < 3; i++) {
            String dest = "F:\\后会无期_" + i + ".mkv";

            // 非直接缓冲区 IO
            // sum += io(src,dest); // 54540
            // 直接缓冲区 NIO
            sum += directBuffer(src, dest); // 49619
        }

        System.out.println("总花费的时间为：" + sum);
    }

    private static long directBuffer(String src, String dest) {
        long start = System.currentTimeMillis();

        FileChannel inChannel = null;
        FileChannel outChannel = null;
        try {
            inChannel = new FileInputStream(src).getChannel();
            outChannel = new FileOutputStream(dest).getChannel();

            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
            while (inChannel.read(byteBuffer) != -1) {
                byteBuffer.flip(); // 修改为读数据模式
                outChannel.write(byteBuffer);
                byteBuffer.clear(); // 清空
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inChannel != null) {
                try {
                    inChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outChannel != null) {
                try {
                    outChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        long end = System.currentTimeMillis();
        return end - start;
    }

    private static long io(String src, String dest) {
        long start = System.currentTimeMillis();

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dest);
            byte[] buffer = new byte[_100Mb];
            while (true) {
                int len = fis.read(buffer);
                if (len == -1) {
                    break;
                }
                fos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        return end - start;
    }
}

3、直接内存OOM与大小的设置

　　直接内存也可能导致OOM异常。由于直接内存在Java堆外，因此它的大小不会直接受限于-Xmx指定的最大堆大小。但是系统内存是有限的，Java堆和直接内存的总和应小于操作系统给出的最大内存。
　　缺点：分配回收成本较高，不受JVM内存回收管理。
　　直接内存大小可以通过MaxDirectMemorySize设置。默认情况与堆的最大值参数一致。
　　代码示例：本地内存OOM，OutOfMemoryError：Direct buffer memory

public class BufferTest2 {
    // 20MB
    private static final int BUFFER = 1024 * 1024 * 20;

    public static void main(String[] args) {
        ArrayList<ByteBuffer> list = new ArrayList<>();

        int count = 0;
        try {
            while (true) {
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);

                list.add(byteBuffer);
                count++;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            System.out.println(count);
        }
    }
}

// 181
// Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory

　　代码示例：直接内存大小设置

// -Xmx20m -XX:MaxDirectMemorySize=10m
public class MaxDirectMemorySizeTest {
    private static final long _1MB = 1024 * 1024;

    public static void main(String[] args) throws IllegalAccessException {
        Field unsafeField = Unsafe.class.getDeclaredFields()[0];
        unsafeField.setAccessible(true);

        Unsafe unsafe = (Unsafe) unsafeField.get(null);
        while (true) {
            unsafe.allocateMemory(_1MB);
        }
    }
}

　　简单理解：java process memory = java heap + native memory