种一棵树最好的时间是十年前，其次是现在

本文整理自BiliBili黑马的JVM视频：https://www.bilibili.com/video/BV1yE411Z7AP

引言

什么是JVM

定义：

Java Virtual Machine - java 程序的运行环境（Java二进制字节码的运行环境）

好处：

  • 一次编写，到处运行
  • 自动内存管理，垃圾回收功能（因为当时对标的是C和C++）
  • 数组下标越界检查
  • 多态（使用虚拟方法调用的机制实现了多态）

比较：

jvm、jre、jdk

是一个逐级向上，包含的关系

内存结构 - 图1

学习JVM有什么用

  • 面试（提高面试竞争力）
  • 理解底层的实现原理
  • 中高级程序员的必备技能

常见的JVM

内存结构 - 图2

参考来源：维基百科

本文JVM都是以HotSpot为基准

学习路线

内存结构 - 图3

内存结构

1. 程序计数器

1.1 定义

ProGram Counter Register 程序计数器（寄存器）

  • 作用，记住下一条jvm指令的执行地址
  • 特点
    • 是线程私有的
    • 不会存在内存溢出

1.2 作用

  1. 0: getstatic #20 // PrintStream out = System.out;
  2. 3: astore_1 // --
  3. 4: aload_1 // out.println(1);
  4. 5: iconst_1 // --
  5. 6: invokevirtual #26 // --
  6. 9: aload_1 // out.println(2);
  7. 10: iconst_2 // --
  8. 11: invokevirtual #26 // --
  9. 14: aload_1 // out.println(3);
  10. 15: iconst_3 // --
  11. 16: invokevirtual #26 // --
  12. 19: aload_1 // out.println(4);
  13. 20: iconst_4 // --
  14. 21: invokevirtual #26 // --
  15. 24: aload_1 // out.println(5);
  16. 25: iconst_5 // --
  17. 26: invokevirtual #26 // --
  18. 29: return
  • 解释器会解释指令为机器码交给cpu执行，程序计数器会记录下一条指令的地址行号，这样下一次解释器会从程序计数器拿到指令然后进行解释执行
  • 多线程的环境下，如果两个线程发生了上下文切换，那么程序计数器会记录线程下一行指令的地址行号，以便于接着往下执行

2. 虚拟机栈

2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

  • 每个线程运行时所需要的内存，称为虚拟机栈
  • 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

问题辨析

  1. 垃圾回收是否涉及栈内存？
    • 不涉及，当方法执行完自动会释放内存
  2. 栈内存分配越大越好吗？
  3. 方法内的局部变量是否线程安全？
  • 如果方法内局部变量没有逃离方法的作用访问，它是线程安全的
  • 如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

2.2 栈内存溢出

栈帧过大、过多、或者第三方类库操作，都有可能造成栈内存溢出 **java.lang.stackOverflowError**

-Xss256k指定栈内存大小！

栈帧过多导致栈内存溢出

栈帧过大导致栈内存溢出

2.3 线程运行诊断

案例1： cpu 占用过多

定位：

  • 用top定位哪个进程对cpu的占用过高
  • **ps H -eo pid,tid,%cpu | grep**进程id （用ps命令进一步定位是哪个线程引起的cpu占用过高）
  • jstack 进程id
    • 可以根据线程id 找到有问题的线程，进一步定位到问题代码的源码行号

案例2：程序运行很长时间没有结果

3. 本地方法栈

一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为Java有时候没法直接和操作系统底层交互，所以需要用到本地方法栈，服务带native关键字的方法

内存结构 - 图4

4.堆

4.1 定义

Heap 堆

  • 通过 **new 关键字**，创建对象都会使用堆内存

特点

  • 它是线程共享的，堆中对象都需要考虑线程安全的问题
  • 有垃圾回收机制

4.2 堆内存溢出

**java.lang.OutofMemoryError ：java heap space**：堆内存溢出
可以使用 -Xmx8m来指定堆内存大小。

可以将堆内存调小一点，这样可以过早的去发现堆内存的溢出

4.3 堆内存诊断

  1. jps 工具
    • 查看当前系统中有哪些 java 进程
  2. jmap 工具
    • 查看堆内存占用情况 jmap - heap 进程id
  3. jconsole 工具
    • 图形界面的，多功能的监测工具，可以连续监测
  4. jvisualvm 工具

5. 方法区

内存结构 - 图5

5.1 定义

JVM规范-方法区定义

Java 虚拟机有一个在所有 Java 虚拟机线程之间共享的方法区域。方法区域类似于用于传统语言的编译代码的存储区域，或者类似于操作系统进程中的“文本”段。它存储每个类的结构，例如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括特殊方法，用于类和实例初始化以及接口初始化方法区域是在虚拟机启动时创建的。尽管方法区域在逻辑上是堆的一部分，但简单的实现可能不会选择垃圾收集或压缩它。此规范不强制指定方法区的位置或用于管理已编译代码的策略。方法区域可以具有固定的大小，或者可以根据计算的需要进行扩展，并且如果不需要更大的方法区域，则可以收缩。方法区域的内存不需要是连续的！

5.2 组成

内存结构 - 图6

在1.6时候方法区的实现叫做永久代

内存结构 - 图7

在1.8时候方法区的实现叫做元空间

当然，不管是在哪个（1.7或1.8）版本，方法区都是一个概念，在1.8时，方法区已经不占用JVM内存了，而是移到 本地内存，同时串池（StringTable）移到了堆（Heap）中

5.3 方法区内存溢出

1.8 之前会导致永久代内存溢出

  • 使用 -XX:MaxPermSize=8m 指定永久代内存大小

1.8 之后会导致元空间内存溢出

  • 使用-XX:MaxMetaspaceSize=8m 指定元空间大小

在1.8的时候，如果不去指定元空间的大小，那么很难看到元空间溢出，因为1.8的元空间是用的是系统物理内存

场景：

  • spring
  • mybatis

在这样框架中，都是使用了字节码动态生成技术，cglib，spring中是动态代理，

**asm**：字节码操纵框架

5.4 运行时常量池

  1. public class Test {    
  2.     public static void main(String[] args) {
  3.         System.out.println("Hello World!");
  4.     }
  5. }

然后使用 **javap -v Test.class** 命令反编译查看结果

内存结构 - 图8

每条指令都会对应常量池表中一个地址，常量池表中的地址可能对应着一个类名、方法名、参数类型等信息

内存结构 - 图9

  • 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
  • 运行时常量池，常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

5.5 StringTable

先看一道面试题：

  1. String s1 = "a";
  2. String s2 = "b";
  3. String s3 = "a" + "b";
  4. String s4 = s1 + s2;
  5. String s5 = "ab";
  6. String s6 = s4.intern();
  7. // 问
  8. System.out.println(s3 == s4); // false
  9. System.out.println(s3 == s5); // true
  10. System.out.println(s3 == s6); // true    
  12. String x2 = new String("c") + new String("d");
  13. String x1 = "cd";
  14. x2.intern();
  15. // 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
  16. System.out.println(x1 == x2); // false
  18. // 如果调换了  true

在1.8，串池（StringTable）是在堆中

5.5 StringTable特性

  • 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是StringBuilder
  • 字符串常量拼接的原理是编译器优化
  • 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中

**intern**方法 1.8
调用字符串对象的 intern方法，会将该字符串对象尝试放入到串池中

  • 如果串池中没有该字符串对象，则放入成功
  • 如果有该字符串对象，则放入失败，无论放入是否成功，都会返回串池中的字符串对象

注意：此时如果调用 intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象

例1：

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         // "a" "b" 被放入串池中，str 则存在于堆内存之中
  4.         String str = new String("a") + new String("b");
  5.         // 调用 str 的 intern 方法，这时串池中没有 "ab" ，则会将该字符串对象放入到串池中，此时堆内存与串池中的 "ab" 是同一个对象
  6.         String st2 = str.intern();
  7.         // 给 str3 赋值，因为此时串池中已有 "ab" ，则直接将串池中的内容返回
  8.         String str3 = "ab";
  9.         // 因为堆内存与串池中的 "ab" 是同一个对象，所以以下两条语句打印的都为 true
  10.         System.out.println(str == st2);
  11.         System.out.println(str == str3);
  12.     }
  13. }

例2：

  1. public class Main {
  2.     // ["ab","a","b"]
  3.     public static void main(String[] args) {
  4.             // 此处创建字符串对象 "ab" ，因为串池中还没有 "ab" ，所以将其放入串池中
  5.             String x = "ab";
  6.             // "a" "b" 被放入串池中，s 则存在于堆内存之中
  7.             String s = new String("a") + new String("b");
  8.             // 将字符传s放入常量池，若果有则不会放入，如果没有则放入常量池，会把池中的对象返回
  9.             String s2 = s.intern();
  10.             System.out.println(s2 == x); // true
  11.             System.out.println(s == x); // false
  12.     }
  13. }

种一棵树最好的时间是十年前，其次是现在

本文整理自BiliBili黑马的JVM视频：https://www.bilibili.com/video/BV1yE411Z7AP

引言

什么是JVM

定义：

Java Virtual Machine - java 程序的运行环境（Java二进制字节码的运行环境）

好处：

  • 一次编写，到处运行
  • 自动内存管理，垃圾回收功能（因为当时对标的是C和C++）
  • 数组下标越界检查
  • 多态（使用虚拟方法调用的机制实现了多态）

比较：

jvm、jre、jdk

是一个逐级向上，包含的关系

内存结构 - 图10

学习JVM有什么用

  • 面试（提高面试竞争力）
  • 理解底层的实现原理
  • 中高级程序员的必备技能

常见的JVM

内存结构 - 图11

参考来源：维基百科

本文JVM都是以HotSpot为基准

学习路线

内存结构 - 图12

内存结构

1. 程序计数器

1.1 定义

ProGram Counter Register 程序计数器（寄存器）

  • 作用，记住下一条jvm指令的执行地址
  • 特点
    • 是线程私有的
    • 不会存在内存溢出

1.2 作用

  1. 0: getstatic #20 // PrintStream out = System.out;
  2. 3: astore_1 // --
  3. 4: aload_1 // out.println(1);
  4. 5: iconst_1 // --
  5. 6: invokevirtual #26 // --
  6. 9: aload_1 // out.println(2);
  7. 10: iconst_2 // --
  8. 11: invokevirtual #26 // --
  9. 14: aload_1 // out.println(3);
  10. 15: iconst_3 // --
  11. 16: invokevirtual #26 // --
  12. 19: aload_1 // out.println(4);
  13. 20: iconst_4 // --
  14. 21: invokevirtual #26 // --
  15. 24: aload_1 // out.println(5);
  16. 25: iconst_5 // --
  17. 26: invokevirtual #26 // --
  18. 29: return
  • 解释器会解释指令为机器码交给cpu执行，程序计数器会记录下一条指令的地址行号，这样下一次解释器会从程序计数器拿到指令然后进行解释执行
  • 多线程的环境下，如果两个线程发生了上下文切换，那么程序计数器会记录线程下一行指令的地址行号，以便于接着往下执行

2. 虚拟机栈

2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

  • 每个线程运行时所需要的内存，称为虚拟机栈
  • 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

问题辨析

  1. 垃圾回收是否涉及栈内存？
    • 不涉及，当方法执行完自动会释放内存
  2. 栈内存分配越大越好吗？
  3. 方法内的局部变量是否线程安全？
  • 如果方法内局部变量没有逃离方法的作用访问，它是线程安全的
  • 如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

2.2 栈内存溢出

栈帧过大、过多、或者第三方类库操作，都有可能造成栈内存溢出 **java.lang.stackOverflowError**

-Xss256k指定栈内存大小！

栈帧过多导致栈内存溢出

栈帧过大导致栈内存溢出

2.3 线程运行诊断

案例1： cpu 占用过多

定位：

  • 用top定位哪个进程对cpu的占用过高
  • **ps H -eo pid,tid,%cpu | grep**进程id （用ps命令进一步定位是哪个线程引起的cpu占用过高）
  • jstack 进程id
    • 可以根据线程id 找到有问题的线程，进一步定位到问题代码的源码行号

案例2：程序运行很长时间没有结果

3. 本地方法栈

一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为Java有时候没法直接和操作系统底层交互，所以需要用到本地方法栈，服务带native关键字的方法

内存结构 - 图13

4.堆

4.1 定义

Heap 堆

  • 通过 **new 关键字**，创建对象都会使用堆内存

特点

  • 它是线程共享的，堆中对象都需要考虑线程安全的问题
  • 有垃圾回收机制

4.2 堆内存溢出

**java.lang.OutofMemoryError ：java heap space**：堆内存溢出
可以使用 -Xmx8m来指定堆内存大小。

可以将堆内存调小一点，这样可以过早的去发现堆内存的溢出

4.3 堆内存诊断

  1. jps 工具
    • 查看当前系统中有哪些 java 进程
  2. jmap 工具
    • 查看堆内存占用情况 jmap - heap 进程id
  3. jconsole 工具
    • 图形界面的，多功能的监测工具，可以连续监测
  4. jvisualvm 工具

5. 方法区

内存结构 - 图14

5.1 定义

JVM规范-方法区定义

Java 虚拟机有一个在所有 Java 虚拟机线程之间共享的方法区域。方法区域类似于用于传统语言的编译代码的存储区域，或者类似于操作系统进程中的“文本”段。它存储每个类的结构，例如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括特殊方法，用于类和实例初始化以及接口初始化方法区域是在虚拟机启动时创建的。尽管方法区域在逻辑上是堆的一部分，但简单的实现可能不会选择垃圾收集或压缩它。此规范不强制指定方法区的位置或用于管理已编译代码的策略。方法区域可以具有固定的大小，或者可以根据计算的需要进行扩展，并且如果不需要更大的方法区域，则可以收缩。方法区域的内存不需要是连续的！

5.2 组成

内存结构 - 图15

在1.6时候方法区的实现叫做永久代

内存结构 - 图16

在1.8时候方法区的实现叫做元空间

当然，不管是在哪个（1.7或1.8）版本，方法区都是一个概念，在1.8时，方法区已经不占用JVM内存了，而是移到 本地内存，同时串池（StringTable）移到了堆（Heap）中

5.3 方法区内存溢出

1.8 之前会导致永久代内存溢出

  • 使用 -XX:MaxPermSize=8m 指定永久代内存大小

1.8 之后会导致元空间内存溢出

  • 使用-XX:MaxMetaspaceSize=8m 指定元空间大小

在1.8的时候，如果不去指定元空间的大小，那么很难看到元空间溢出，因为1.8的元空间是用的是系统物理内存

场景：

  • spring
  • mybatis

在这样框架中，都是使用了字节码动态生成技术，cglib，spring中是动态代理，

**asm**：字节码操纵框架

5.4 运行时常量池

  1. public class Test {    
  2.     public static void main(String[] args) {
  3.         System.out.println("Hello World!");
  4.     }
  5. }

然后使用 **javap -v Test.class** 命令反编译查看结果

内存结构 - 图17

每条指令都会对应常量池表中一个地址，常量池表中的地址可能对应着一个类名、方法名、参数类型等信息

内存结构 - 图18

  • 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
  • 运行时常量池，常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

5.5 StringTable

先看一道面试题：

  1. String s1 = "a";
  2. String s2 = "b";
  3. String s3 = "a" + "b";
  4. String s4 = s1 + s2;
  5. String s5 = "ab";
  6. String s6 = s4.intern();
  7. // 问
  8. System.out.println(s3 == s4); // false
  9. System.out.println(s3 == s5); // true
  10. System.out.println(s3 == s6); // true    
  12. String x2 = new String("c") + new String("d");
  13. String x1 = "cd";
  14. x2.intern();
  15. // 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
  16. System.out.println(x1 == x2); // false
  18. // 如果调换了  true

在1.8，串池（StringTable）是在堆中

5.5 StringTable特性

  • 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是StringBuilder
  • 字符串常量拼接的原理是编译器优化
  • 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中

**intern**方法 1.8
调用字符串对象的 intern方法，会将该字符串对象尝试放入到串池中

  • 如果串池中没有该字符串对象，则放入成功
  • 如果有该字符串对象，则放入失败，无论放入是否成功，都会返回串池中的字符串对象

注意：此时如果调用 intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象

例1：

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         // "a" "b" 被放入串池中，str 则存在于堆内存之中
  4.         String str = new String("a") + new String("b");
  5.         // 调用 str 的 intern 方法，这时串池中没有 "ab" ，则会将该字符串对象放入到串池中，此时堆内存与串池中的 "ab" 是同一个对象
  6.         String st2 = str.intern();
  7.         // 给 str3 赋值，因为此时串池中已有 "ab" ，则直接将串池中的内容返回
  8.         String str3 = "ab";
  9.         // 因为堆内存与串池中的 "ab" 是同一个对象，所以以下两条语句打印的都为 true
  10.         System.out.println(str == st2);
  11.         System.out.println(str == str3);
  12.     }
  13. }

例2：

  1. public class Main {
  2.     // ["ab","a","b"]
  3.     public static void main(String[] args) {
  4.             // 此处创建字符串对象 "ab" ，因为串池中还没有 "ab" ，所以将其放入串池中
  5.             String x = "ab";
  6.             // "a" "b" 被放入串池中，s 则存在于堆内存之中
  7.             String s = new String("a") + new String("b");
  8.             // 将字符传s放入常量池，若果有则不会放入，如果没有则放入常量池，会把池中的对象返回
  9.             String s2 = s.intern();
  10.             System.out.println(s2 == x); // true
  11.             System.out.println(s == x); // false
  12.     }
  13. }

常量池维护的是引用，所有的对象都在堆中

5.6 StringTable的位置

**jdk1.6** StringTable 位置是在永久代中

**jdk1.8** StringTable 位置是在堆中

因为垃圾回收不会发生在永久代

5.7 StringTable 垃圾回收

PermGen space：1.6串池使用永久代的空间

  1. # jdk8
  2. -Xmx10m #指定堆内存大小  
  3. -XX: - UseGCOverheadLimit # + Use..打开开关，-Use..关闭开关
  4. # jdk6
  5. -XX:MaxPermSize = 10m 
  7. -XX:+PrintStringTableStatistics  #打印字符串常量池信息
  8. -XX:+PrintGCDetails
  9. -verbose:gc #打印 gc 的次数，耗费时间等信息
  1. /**
  2.  * 演示 StringTable 垃圾回收
  3.  * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
  4.  */
  5. public class Code_05_StringTableTest {
  6.     public static void main(String[] args) {
  7.         int i = 0;
  8.         try {
  9.             for(int j = 0; j < 10000; j++) { // j = 100, j = 10000
  10.                 String.valueOf(j).intern();
  11.                 i++;
  12.             }
  13.         }catch (Exception e) {
  14.             e.printStackTrace();
  15.         }finally {
  16.             System.out.println(i);
  17.         }
  18.     }
  19. }

5.8 StringTable性能调优

  • 因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间
  1. -XX:StringTableSize=桶个数（最少设置为 1009 以上）

这个地方因为当桶个数变少，导致哈希碰撞变多，哈希查找变慢，底层的红黑树不断在添加元素

  • 考虑是否需要将字符串对象入池，可以通过 intern方法减少重复入池

6. 直接内存

不属于Java虚拟机内存，属于系统内存

6.1 定义

**Direct Memory**

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

6.2 使用直接内存的好处

文件读写流程：

内存结构 - 图19

因为 java 不能直接操作文件管理，需要切换到内核态，使用本地方法进行操作，然后读取磁盘文件，会在系统内存中创建一个缓冲区，将数据读到系统缓冲区， 然后在将系统缓冲区数据，复制到 java 堆内存中。缺点是数据存储了两份，在系统内存中有一份，java 堆中有一份，造成了不必要的复制。

使用了 DirectBuffer 文件读取流程

内存结构 - 图20

直接内存是操作系统和 Java 代码都可以访问的一块区域，无需将代码从系统内存复制到 Java 堆内存，从而提高了效率

6.3 直接内存回收原理

总结:

  • 使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory方法
  • ByteBuffer的实现类内部，使用了 Cleaner（虚引用）来监测 ByteBuffer对象，一旦ByteBuffer对象被垃圾回收，那么就会由 ReferenceHandler线程通过 Cleaner的 clean方法调用 freeMemory来释放直接内存

不建议普通程序员使用unSafe

  1. public class Code_06_DirectMemoryTest {
  3.     public static int _1GB = 1024 * 1024 * 1024;
  5.     public static void main(String[] args) throws IOException, NoSuchFieldException, IllegalAccessException {
  6. //        method();
  7.         method1();
  8.     }
  10.     // 演示 直接内存 是被 unsafe 创建与回收
  11.     // 推荐使用 unsafe去释放时间内存
  12.     private static void method1() throws IOException, NoSuchFieldException, IllegalAccessException {
  14.         // 获取unsafe对象
  15.         Field field = Unsafe.class.getDeclaredField("theUnsafe");
  16.         field.setAccessible(true);
  17.         Unsafe unsafe = (Unsafe)field.get(Unsafe.class);
  19.         // 分配内存  
  20.         long base = unsafe.allocateMemory(_1GB); // 直接内存地址
  21.         unsafe.setMemory(base,_1GB, (byte)0);
  22.         System.in.read();
  24.         // 释放内存
  25.         unsafe.freeMemory(base); // 通过地址去释放
  26.         System.in.read();
  27.     }
  29.     // 演示 直接内存被 释放
  30.     private static void method() throws IOException {
  31.         ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1GB);
  32.         System.out.println("分配完毕");
  33.         System.in.read();
  34.         System.out.println("开始释放");
  35.         byteBuffer = null;
  36.         System.gc(); // 手动 gc
  37.         System.in.read();
  38.     }
  39. }

直接内存的回收不是通过 JVM 的垃圾回收来释放的，而是通过**unsafe.freeMemory** 来手动释放

第一步：allocateDirect的实现

  1. public static ByteBuffer allocateDirect(int capacity) {
  2.     return new DirectByteBuffer(capacity);
  3. }

底层是创建了一个 DirectByteBuffer 对象

第二步：DirectByteBuffer类

  1. DirectByteBuffer(int cap) {   // package-private
  3.     super(-1, 0, cap, cap);
  4.     boolean pa = VM.isDirectMemoryPageAligned();
  5.     int ps = Bits.pageSize();
  6.     long size = Math.max(1L, (long)cap + (pa ? ps : 0));
  7.     Bits.reserveMemory(size, cap);
  9.     long base = 0;
  10.     try {
  11.          // 申请内存
  12.         base = unsafe.allocateMemory(size);
  13.     } catch (OutOfMemoryError x) {
  14.         Bits.unreserveMemory(size, cap);
  15.         throw x;
  16.     }
  17.     unsafe.setMemory(base, size, (byte) 0);
  18.     if (pa && (base % ps != 0)) {
  19.         // Round up to page boundary
  20.         address = base + ps - (base & (ps - 1));
  21.     } else {
  22.         address = base;
  23.     }
  24.     // 通过虚引用，来实现直接内存的释放，this为虚引用的实际对象, 第二个参数是一个回调，实现了 runnable 接口，run 方法中通过 unsafe 释放内存
  25.     cleaner = Cleaner.create(this, new Deallocator(base, size, cap));  // Deallocator是一个任务对象，因为他实现了runnable接口
  26.     att = null;
  27. }

这里调用了一个 Cleaner的 create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象（这里是 DirectByteBuffer）被回收以后，就会调用 Cleaner的 clean方法，来清除直接内存中占用的内存

  1.  public void clean() {
  2.      if (remove(this)) {
  3.          try {
  4.              // 都用函数的 run 方法, 释放内存
  5.              this.thunk.run();
  6.          } catch (final Throwable var2) {
  7.              AccessController.doPrivileged(new PrivilegedAction<Void>() {
  8.                  public Void run() {
  9.                      if (System.err != null) {
  10.                          (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
  11.                      }
  13.                      System.exit(1);
  14.                      return null;
  15.                  }
  16.              });
  17.          }
  18.      }
  19.  }

可以看到关键的一行代码， this.thunk.run()，thunk 是 Runnable对象。run方法就是回调 Deallocator中的 run方法，

  1. public void run() {
  2.     if (address == 0) {
  3.         // Paranoia
  4.         return;
  5.     }
  6.     // 释放内存
  7.     unsafe.freeMemory(address);
  8.     address = 0;
  9.     Bits.unreserveMemory(size, capacity);
  10. }

注意：

  1. /**
  2.      * -XX:+DisableExplicitGC 显示的
  3.      */
  4. private static void method() throws IOException {
  5.     ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1GB);
  6.     System.out.println("分配完毕");
  7.     System.in.read();
  8.     System.out.println("开始释放");
  9.     byteBuffer = null;
  10.     System.gc(); // 显示的垃圾回收，Full GC
  11.     System.in.read();
  12. }

一般用 jvm 调优时，会加上下面的参数：

  1. -XX:+DisableExplicitGC  // 禁止显示的 GC

意思就是禁止我们手动的 GC，比如手动 System.gc() 无效，它是一种 full gc，会回收新生代、老年代，会造成程序执行的时间比较长

不过还是建议使用