1. 概述

JDK8及之后方法区的实现变成了元空间，元空间不再使用JVM内存，而是直接使用系统内存，故称为直接内存。对于元空间来说，它具有如下的特点：

  • 元空间不再位于运行时数据区，也不是Java虚拟机规范中定义的区域
  • 元空间直接使用系统内存空间
  • 访问直接内存的效率更高，读写性能更好

元空间的思想来源于Java中的NIO，它通过堆中的DirectByteBuffer操作本地内存。它允许程序使用直接内存，用于数据缓冲区。

  1. import java.nio.ByteBuffer;
  2. import java.util.Scanner;
  4. public class BufferTest {
  5.     private static final int BUFFER = 1024 * 1024 * 1024;//1GB
  7.     public static void main(String[] args){
  8.         //直接分配本地内存空间
  9.         ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
  10.         System.out.println("直接内存分配完毕，请求指示！");
  12.         Scanner scanner = new Scanner(System.in);
  13.         scanner.next();
  15.         System.out.println("直接内存开始释放！");
  16.         byteBuffer = null;
  17.         System.gc();
  18.         scanner.next();
  19.     }
  20. }

2. 直接缓冲与非直接缓冲

2.1 非直接缓冲

非直接缓冲方式读写文件时，需要与磁盘进行交互。因此，它需要用户态和内核态之间的切换。而用户态和内核态之间的相关切换通常开销较大，因此，使用非直接缓冲方式读写文件性能较低。如下所示：
image-20200604103934257.png

  • 当应用程序想要读取物理磁盘上的数据时，首先需要从用户态切换到内核态，由系统负责数据的读取，将数据读取到内核地址空间中。然后再将内核地址空间中的数据复制到用户地址空间中，这样程序才可以使用
  • 当应用程序要往物理磁盘中写入数据时，过程和上面的正好相反，它同样需要进行数据的复制，需要维护两块地址空间来完成写入操作

2.2 直接缓冲

当使用NIO时，操作系统会划出一块区域作为直接缓存区，此时Java程序可以直接访问该缓冲区即可，不必进行状态的切换和数据的复制。
image-20200604104353671.png

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.nio.ByteBuffer;
  5. import java.nio.channels.FileChannel;
  7. public class BufferTest1 {
  8.     private static final String TO = "C:test.txt";
  9.     private static final int _100Mb = 1024 * 1024 * 100;
  11.     public static void main(String[] args) {
  12.         long sum = 0;
  13.         String src = "C:test.txt";
  14.         for (int i = 0; i < 3; i++) {
  15.             String dest = "D:test" + i + ".txt";
  16.             sum += directBuffer(src,dest);
  17.         }
  18.         System.out.println("总花费的时间为：" + sum );
  19.     }
  21.     // NIO方式
  22.     private static long directBuffer(String src,String dest) {
  23.         long start = System.currentTimeMillis();
  25.         FileChannel inChannel = null;
  26.         FileChannel outChannel = null;
  27.         try {
  28.             inChannel = new FileInputStream(src).getChannel();
  29.             outChannel = new FileOutputStream(dest).getChannel();
  31.             ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
  32.             while (inChannel.read(byteBuffer) != -1) {
  33.                 byteBuffer.flip();//修改为读数据模式
  34.                 outChannel.write(byteBuffer);
  35.                 byteBuffer.clear();//清空
  36.             }
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         } finally {
  40.             if (inChannel != null) {
  41.                 try {
  42.                     inChannel.close();
  43.                 } catch (IOException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.             }
  47.             if (outChannel != null) {
  48.                 try {
  49.                     outChannel.close();
  50.                 } catch (IOException e) {
  51.                     e.printStackTrace();
  52.                 }
  53.             }
  54.         }
  55.         long end = System.currentTimeMillis();
  56.         return end - start;
  57.     }
  59.     // 字节缓冲流方式
  60.     private static long io(String src,String dest) {
  61.         long start = System.currentTimeMillis();
  63.         FileInputStream fis = null;
  64.         FileOutputStream fos = null;
  65.         try {
  66.             fis = new FileInputStream(src);
  67.             fos = new FileOutputStream(dest);
  68.             byte[] buffer = new byte[_100Mb];
  69.             while (true) {
  70.                 int len = fis.read(buffer);
  71.                 if (len == -1) {
  72.                     break;
  73.                 }
  74.                 fos.write(buffer, 0, len);
  75.             }
  76.         } catch (IOException e) {
  77.             e.printStackTrace();
  78.         } finally {
  79.             if (fis != null) {
  80.                 try {
  81.                     fis.close();
  82.                 } catch (IOException e) {
  83.                     e.printStackTrace();
  84.                 }
  85.             }
  86.             if (fos != null) {
  87.                 try {
  88.                     fos.close();
  89.                 } catch (IOException e) {
  90.                     e.printStackTrace();
  91.                 }
  93.             }
  94.         }
  95.         long end = System.currentTimeMillis();
  96.         return end - start;
  97.     }
  98. }

3. 直接内存的OOM

虽然直接内存只取决于系统内存的大小情况，但也可能出现OOM。因为Java堆和直接内存的总和依然受限于系统内存的最大值，当堆所占空间太大时，直接内存太小时就可能会出现OOM。

直接内存大小可通过MaxDirectMemorySize参数设置，如果不自定义设置，那么它的大小将和堆的最大值-Xmx参数值一样。

  1. import java.nio.ByteBuffer;
  2. import java.util.ArrayList;
  4. public class OOMTest {
  5.     private static final int BUFFER = 1024 * 1024 * 20;//20MB
  7.     public static void main(String[] args) {
  8.         ArrayList<ByteBuffer> list = new ArrayList<>();
  9.         int count = 0;
  10.         try {
  11.             while(true){
  12.                 ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
  13.                 list.add(byteBuffer);
  14.                 count++;
  15.                 try {
  16.                     Thread.sleep(100);
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         } finally {
  22.             System.out.println(count);
  23.         }
  24.     }
  25. }

当直接内存用尽时，程序就会抛出OOM异常

  1. 89
  2. Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
  3.     at java.nio.Bits.reserveMemory(Bits.java:694)
  4.     at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
  5.     at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
  6.     at DirectBuffer.OOMTest.main(OOMTest.java:14)

4.总结

直接内存使用系统内存，因此使用性能较高。但是它分配回收成本高，而且不受JVM内存回收管理。