六、直接内存
6.1、定义
Direct Memory：直接内存，并不属于java虚拟机的内存管理，而是属于操作系统的内存。
NIO有一个ByteBuffer，这个ByteBuffer所使用与分配的内存就是直接内存，它不属于jvm管理。
传统的IO是阻塞IO。
三个特点：
常见于 NIO 操作时，用于数据缓冲区。
分配回收成本较高，但读写性能高。
不受 JVM 内存回收管理。（通过一个虚引用来进行的）
6.2、IO与直接内存比较
6.2.1、比较案例演示
案例描述：一个是使用普通IO进行输入输出、另一个使用直接内存来进行输入输出。操作的视频大小为310MB。
import java.io.*; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class Main { static final String FROM = "C:\\Users\\93997\\Desktop\\新建文件夹\\from\\math.mp4"; static final String TO = "C:\\Users\\93997\\Desktop\\新建文件夹\\to\\math1.mp4"; static final int _1Mb = 1024 * 1024; public static void main(String[] args) { io(); // io 用时：606.3063 directBuffer(); // directBuffer 用时：246.3773 } 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);//反转指针指向：读/写指针position指到缓冲区头部 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); } }
结论：使用直接内存来进行读取输出效率比普通IO要高！
6.2.2、直接内存原理分析
传统的IO操作：
首先会从用户态切换到内核态(CPU的状态变化)，切换到内存态之后可以使用c语言的函数去真正读取磁盘文件的内容。
切换到内存态之后会在操作系统中划分出来一块缓冲区(系统缓冲区)，接着会先将磁盘文件的内容读取到系统缓冲区，注意java代码是不能够对磁盘文件进行读写操作的。
java的话会在堆内存之中分配一块java缓冲区(如new byte[1024])，之后就会不断的从系统缓冲区读取数据到java缓冲区。
CPU会再次切换到用户态后进行读取输入输出文件操作(针对于java缓冲区进行操作)，最终将文件复制到目标位置。
在这个过程中实际相当于会复制两份的操作，造成不必要的数据复制，效率不是很高。
直接内存(direct memory)：会划分出一块直接内存区域，在这块区域我们java代码可以直接进行访问，系统也同样可以访问，两块代码是系统共享的一块区域，之后磁盘读取的文件会读取到直接内存，之后java代码同样也可以访问到这块直接内存中。
本质：比之前的IO少复制了一次缓冲区的操作，提高了效率。
6.2.3、直接内存-内存溢出
代码说明：每次分配1G直接内存空间，不断循环直到抛出内存溢出报错。
public class Main { static int _100Mb = 1024 * 1024 * 100; public static void main(String[] args) throws IOException { List<ByteBuffer> list = new ArrayList<>(); int i = 0; System.in.read(); try { while (true) { ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);//分配直接内存1G list.add(byteBuffer); i++; } } finally { System.out.println(i); System.in.read(); } } }
说明：直接内存不由JVM来进行管理，但是对于直接内存的申请创建也是有限制的，差不多4G左右内存。
6.3、直接内存（释放原理）
6.3.1、GC垃圾回收释放？
下面的程序我们来尝试使用显示GC垃圾回收的方式来释放直接内存：
i
mport java.io.*; import java.nio.ByteBuffer; public class Main { 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(); } }
可以看到当前分配了1G的内存空间
此时就会有疑问了，之前不是说直接内存不受JVM管理嘛，那为什么这里调用GC垃圾回收方法能够将直接内存回收呢？答案：借助虚引用实现，真正分配与释放借助Unsafe这个类。
6.3.2、释放与分配原理探究（Unsafe类）
Unsafe类：干一些分配或释放直接内存的事情，一般都是JDK内部会进行这样一些操作。
案例描述：通过Unsafe来进行分配与释放直接内存。
import sun.misc.Unsafe; import java.io.*; import java.lang.reflect.Field; public class Main { 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.out.println("已分配直接内存"); System.in.read(); // 释放内存 unsafe.freeMemory(base); System.out.println("释放直接内存"); System.in.read(); } //借助反射来获取到Unsafe实例 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); } } }
效果：可以看到通过Unsafe类可以对直接内存进行分配与释放，那么其实我们可以联想到之前的分配内存空间以及垃圾回收肯定也与这个Unsafe类有关！
6.3.3、源码深入（案例+源码）
之前分配直接内存、释放直接内存的代码我们调用的是如下两条：
ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);//分配直接内存 System.gc();//显示垃圾回收 Full GC
分配直接内存
直接看源码即可：内部通过Unsafe来进行分配内存，并且与此同时创建一个虚引用绑定该ByteBuffer实体类，一旦该实体类不被引用进行垃圾回收时就会调用clean()方法来进行
public static ByteBuffer allocateDirect(int capacity) { return new DirectByteBuffer(capacity); } DirectByteBuffer(int cap) { 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);//使用Unsafe类来进行分配直接内存 } 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：虚引用类型，若是所关联的对象(指的是bb)被回收时，那么Cleaner就会触发该虚引用的clean方法，该方法中就会执行对应的回调方法（就是第二个参数Deallocator中的run()方法）。对应在后台一个reference线程里执行，该线程会专门检测这些虚引用的情况，一旦虚引用对象关联的实际对象被回收掉以后就会调用该虚引用的clean方法。然后执行任务对象，最终任务对象再来真正执行freeMemory方法。 cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); att = null; } //************看一下Cleaner类************** public class Cleaner extends PhantomReference<Object> { private Cleaner(Object var1, Runnable var2) { super(var1, dummyQueue); this.thunk = var2; } //第二个参数就是调用指定的回调方法 public static Cleaner create(Object var0, Runnable var1) { return var1 == null ? null : add(new Cleaner(var0, var1)); } //一旦虚引用关联的对象被回收就会执行这个方法 public void clean() { if (remove(this)) { try { //触发回调方法，来进行垃圾回收，见下面的 this.thunk.run(); } catch (final Throwable var2) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { if (System.err != null) { (new Error("Cleaner terminated abnormally", var2)).printStackTrace(); } System.exit(1); return 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; } //clean()方法执行触发该run()方法，还是调用的Unsafe来执行清理直接内存操作 public void run() { if (address == 0) { // Paranoia return; } //清理直接内存 unsafe.freeMemory(address); address = 0; Bits.unreserveMemory(size, capacity); } }
System.gc();//显示垃圾回收 Full GC
接下来说明一下为什么要额外进行调用下面的代码来进行直接内存的垃圾回收：
byteBuffer = null; //不进行引用 System.gc(); // 显式的垃圾回收，Full GC，对年轻代、老年代都进行垃圾回收，开销较大
一般来说只有在内存空间不足的情况下会进行垃圾回收，若是byteBuffer不进行引用，可能不会触发GC垃圾回收。这也就是为什么我们还要显示调用GC的原因。
一旦byteBuffer不被引用，那么对应的虚引用就会被触发其中的clean()方法来进行释放直接内存操作，这一操作是一个守护进程完成的！
总结：垃圾回收只能释放java的内存，对于直接内存需要我们手动来去调用unfase的freeMemory方法来完成对内存的释放。
6.3.4、直接内存释放最好方式
若是直接使用显示GC方法调用来进行清理直接内存，其实是不太妥当的，因为该显示调用是进行Full GC，无论是年轻代还是老年代都会进行垃圾回收操作，在程序中占用的开销较大。
推荐使用unsafe来进行手动管理直接内存。就是6.3.2案例来进行直接内存的垃圾回收！
6.4、JVM调优（禁用GC垃圾回收）
JVM参数：-XX:+DisableExplicitGC，禁止显示进行GC垃圾回收。
原因：避免程序中有手动进行GC垃圾回收的操作，显示GC是Full GC，会有一定的开销，所以在进行调优时禁用。
import java.io.*; import java.nio.ByteBuffer; public class Main { 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(); } }
