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