1. JVM 内存结构

要求

  • 掌握 JVM 内存结构划分

  • 尤其要知道方法区、永久代、元空间的关系

    1.1.JVM 内存结构划分

    image.png

  • 执行 javac 命令编译源代码为字节码

  • 执行 java 命令
    1. 创建 JVM，调用类加载子系统加载 class，将类的信息存入方法区
    2. 创建 main 线程，使用的内存区域是 JVM 虚拟机栈，开始执行 main 方法代码
    3. 如果遇到了未见过的类，会继续触发类加载过程，同样会存入方法区
    4. 需要创建对象，会使用堆内存来存储对象
    5. 不再使用的对象，会由垃圾回收器在内存不足时回收其内存
    6. 调用方法时，方法内的局部变量、方法参数所使用的是 JVM 虚拟机栈中的栈帧内存
    7. 调用方法时，先要到方法区获得到该方法的字节码指令，由解释器将字节码指令解释为机器码执行
    8. 调用方法时，会将要执行的指令行号读到程序计数器，这样当发生了线程切换，恢复时就可以从中断的位置继续
    9. 对于非 java 实现的方法调用，使用内存称为本地方法栈
    10. 对于热点方法调用，或者频繁的循环代码，由 JIT 即时编译器将这些代码编译成机器码缓存，提高执行性能

说明

  • 加粗字体代表了 JVM 虚拟机组件
  • 对于 Oracle 的 Hotspot 虚拟机实现，不区分虚拟机栈和本地方法栈

总结：
方法区-类，类变量，常量
堆-对象实例
栈-局部变量，方法参数等方法信息
程序计数器-线程切换恢复
解释器-.class文件转为cpu看得懂的机器码
JIT及时编译器-热点方法缓存为机器码
本地方法接口-native
JVM结构包含执行引擎、运行时数据区、本地方法库、类加载器

1.2.会发生内存溢出的区域

  • 不会出现内存溢出的区域 – 程序计数器
  • 出现 OutOfMemoryError 的情况
    • 堆内存耗尽 – 对象越来越多，又一直在使用，不能被垃圾回收
    • 方法区内存耗尽 – 加载的类越来越多，很多框架都会在运行期间动态产生新的类
    • 虚拟机栈累积 – 每个线程最多会占用 1 M 内存，线程个数越来越多，而又长时间运行不销毁时

  • 出现 StackOverflowError 的区域

    • JVM 虚拟机栈，原因有方法递归调用未正确结束、反序列化 json 时循环引用

      1.3.方法区、永久代、元空间的关系

  • 方法区是 JVM 规范中定义的一块内存区域，用来存储类元数据、方法字节码、即时编译器需要的信息等

  • 永久代是 Hotspot 虚拟机对 JVM 方法区的实现（1.8 之前）
  • 元空间是 Hotspot 虚拟机对 JVM 方法区的另一种实现（1.8 以后），使用本地内存作为这些信息的存储空间

image.png
从这张图学到三点

  • 当第一次用到某个类是，由类加载器将 class 文件的类元信息读入，并存储于元空间
  • X，Y 的类元信息是存储于元空间中，无法直接访问
  • 可以用 X.class，Y.class 间接访问类元信息，它们俩属于 java 对象，我们的代码中可以使用

image.png
从这张图可以学到

  • 堆内存中：当一个类加载器对象，这个类加载器对象加载的所有类对象，这些类对象对应的所有实例对象都没人引用时，GC 时就会对它们占用的对内存进行释放
  • 元空间中：内存释放以类加载器为单位，当堆中类加载器内存释放时，对应的元空间中的类元信息也会释放

2. JVM 内存参数

要求

  • 熟悉常见的 JVM 参数，尤其和大小相关的

    2.1.堆内存，按大小设置

    image.png
    解释：

  • -Xms 最小堆内存（包括新生代和老年代）

  • -Xmx 最大堆内存（包括新生代和老年代）
  • 通常建议将 -Xms 与 -Xmx 设置为大小相等，即不需要保留内存，不需要从小到大增长，这样性能较好
  • -XX:NewSize 与 -XX:MaxNewSize 设置新生代的最小与最大值，但一般不建议设置，由 JVM 自己控制
  • -Xmn 设置新生代大小，相当于同时设置了 -XX:NewSize 与 -XX:MaxNewSize 并且取值相等
  • 保留是指，一开始不会占用那么多内存，随着使用内存越来越多，会逐步使用这部分保留内存。下同


2.2.堆内存，按比例设置

image.png
解释：

  • -XX:NewRatio=2:1 表示老年代占两份，新生代占一份
  • -XX:SurvivorRatio=4:1 表示新生代分成六份，伊甸园占四份，from 和 to 各占一份

默认-XX:NewRatio=2:1、-XX:SurvivorRatio=8:1

2.3.元空间内存设置

image.png
解释：

  • class space 存储类的基本信息，最大值受 -XX:CompressedClassSpaceSize 控制
  • non-class space 存储除类的基本信息以外的其它信息（如方法字节码、注解等）
  • class space 和 non-class space 总大小受 -XX:MaxMetaspaceSize 控制

注意：

  • 这里 -XX:CompressedClassSpaceSize 这段空间还与是否开启了指针压缩有关，这里暂不深入展开，可以简单认为指针压缩默认开启

2.4.代码缓存内存设置（*）

image.png
解释：

  • 如果 -XX:ReservedCodeCacheSize < 240m，所有优化机器代码不加区分存在一起
  • 否则，分成三个区域（图中笔误 mthod 拼写错误，少一个 e）
    • non-nmethods - JVM 自己用的代码
    • profiled nmethods - 部分优化的机器码
    • non-profiled nmethods - 完全优化的机器码


2.5.线程内存设置

默认1m
image.png

3. JVM 垃圾回收

要求

  • 掌握垃圾回收算法
  • 掌握分代回收思想
  • 理解三色标记及漏标处理
  • 了解常见垃圾回收器

    3.1.三种垃圾回收算法

    标记清除法
    image.png
    解释：
  1. 找到 GC Root 对象，即那些一定不会被回收的对象，如正执行方法内局部变量引用的对象、静态变量引用的对象
  2. 标记阶段：沿着 GC Root 对象的引用链找，直接或间接引用到的对象加上标记
  3. 清除阶段：释放未加标记的对象占用的内存

要点：

  • 标记速度与存活对象线性关系
  • 清除速度与内存大小线性关系
  • 缺点是会产生内存碎片

标记整理法
image.png
解释：

  1. 前面的标记阶段、清理阶段与标记清除法类似
  2. 多了一步整理的动作，将存活对象向一端移动，可以避免内存碎片产生

特点：

  • 标记速度与存活对象线性关系
  • 清除与整理速度与内存大小成线性关系
  • 缺点是性能上较慢

标记复制法
image.png
解释：

  1. 将整个内存分成两个大小相等的区域，from 和 to，其中 to 总是处于空闲，from 存储新创建的对象
  2. 标记阶段与前面的算法类似
  3. 在找出存活对象后，会将它们从 from 复制到 to 区域，复制的过程中自然完成了碎片整理
  4. 复制完成后，交换 from 和 to 的位置即可

特点：

  • 标记与复制速度与存活对象成线性关系
  • 缺点是会占用成倍的空间

3.2.GC 与分代回收算法

GC 的目的在于实现无用对象内存自动释放，减少内存碎片、加快分配速度
GC要点

  • 回收区域是堆内存，不包括虚拟机栈
  • 判断无用对象，使用可达性分析算法，三色标记法标记存活对象，回收未标记对象
  • GC 具体的实现称为垃圾回收器
  • GC 大都采用了分代回收思想
    • 理论依据是大部分对象朝生夕灭，用完立刻就可以回收，另有少部分对象会长时间存活，每次很难回收
    • 根据这两类对象的特性将回收区域分为新生代和老年代，新生代采用标记复制法、老年代一般采用标记整理法
  • 根据 GC 的规模可以分成 Minor GC，Mixed GC，Full GC

分代回收

  1. 伊甸园 eden，最初对象都分配到这里，与幸存区 survivor（分成 from 和 to）合称新生代

image.png

  1. 当伊甸园内存不足，标记伊甸园与 from（现阶段没有）的存活对象

image.png

  1. 将存活对象采用复制算法复制到 to 中，复制完毕后，伊甸园和 from 内存都得到释放

image.png

  1. 将 from 和 to 交换位置

image.png

  1. 经过一段时间后伊甸园的内存又出现不足

image.png

  1. 标记伊甸园与 from（现阶段没有）的存活对象

image.png

  1. 将存活对象采用复制算法复制到 to 中

image.png

  1. 复制完毕后，伊甸园和 from 内存都得到释放

image.png

  1. 将 from 和 to 交换位置

image.png

  1. 老年代 old，当幸存区对象熬过几次回收（最多15次），晋升到老年代（幸存区内存不足或大对象会导致提前晋升）

3.3.三色标记

即用三种颜色记录对象的标记状态

  • 黑色 – 已标记
  • 灰色 – 标记中
  • 白色 – 还未标记
  1. 起始的三个对象还未处理完成，用灰色表示

image.png

  1. 该对象的引用已经处理完成，用黑色表示，黑色引用的对象变为灰色

image.png

  1. 依次类推

image.png

  1. 沿着引用链都标记了一遍

image.png

  1. 最后为标记的白色对象，即为垃圾

image.png

3.4.并发漏标问题

比较先进的垃圾回收器都支持并发标记，即在标记过程中，用户线程仍然能工作。但这样带来一个新的问题，如果用户线程修改了对象引用，那么就存在漏标问题。例如：

  1. 如图所示标记工作尚未完成

image.png

  1. 用户线程同时在工作，断开了第一层 3、4 两个对象之间的引用，这时对于正在处理 3 号对象的垃圾回收线程来讲，它会将 4 号对象当做是白色垃圾

image.png

  1. 但如果其他用户线程又建立了 2、4 两个对象的引用，这时因为 2 号对象是黑色已处理对象了，因此垃圾回收线程不会察觉到这个引用关系的变化，从而产生了漏标

image.png

  1. 如果用户线程让黑色对象引用了一个新增对象，一样会存在漏标问题

image.png
因此对于并发标记而言，必须解决漏标问题，也就是要记录标记过程中的变化。有两种解决方法：

  1. Incremental Update 增量更新法，CMS 垃圾回收器采用
    • 思路是拦截每次赋值动作，只要赋值发生，被赋值的对象就会被记录下来，在重新标记阶段再确认一遍
  2. Snapshot At The Beginning，SATB 原始快照法，G1 垃圾回收器采用
    • 思路也是拦截每次赋值动作，不过记录的对象不同，也需要在重新标记阶段对这些对象二次处理
    • 新加对象会被记录
    • 被删除引用关系的对象也被记录


3.5.垃圾回收器种类

垃圾回收器 - Parallel GC

  • eden 内存不足发生 Minor GC，采用标记复制算法，需要暂停用户线程
  • old 内存不足发生 Full GC，采用标记整理算法，需要暂停用户线程
  • 注重吞吐量

垃圾回收器 - ConcurrentMarkSweep GC

  • 它是工作在 old 老年代，支持并发标记的一款回收器，采用并发清除算法
    • 并发标记时不需暂停用户线程
    • 重新标记时仍需暂停用户线程
  • 如果并发失败（即回收速度赶不上创建新对象速度），会触发 Full GC
  • 注重响应时间

垃圾回收器 - G1 GC

  • 响应时间与吞吐量兼顾
  • 划分成多个区域，每个区域都可以充当 eden，survivor，old， humongous，其中 humongous 专为大对象准备
  • 分成三个阶段：新生代回收、并发标记、混合收集
  • 如果并发失败（即回收速度赶不上创建新对象速度），会触发 Full GC

3.6.G1垃圾回收过程


G1 回收阶段 - 新生代回收

  1. 初始时，所有区域都处于空闲状态

image.png

  1. 创建了一些对象，挑出一些空闲区域作为伊甸园区存储这些对象

image.png

  1. 当伊甸园需要垃圾回收时，挑出一个空闲区域作为幸存区，用复制算法复制存活对象，需要暂停用户线程

image.png

  1. 复制完成，将之前的伊甸园内存释放

image.png

  1. 随着时间流逝，伊甸园的内存又有不足

image.png

  1. 将伊甸园以及之前幸存区中的存活对象，采用复制算法，复制到新的幸存区，其中较老对象晋升至老年代

image.png

  1. 释放伊甸园以及之前幸存区的内存

image.png
G1 回收阶段 - 并发标记与混合收集

  1. 当老年代占用内存超过阈值后，触发并发标记，这时无需暂停用户线程

image.png

  1. 并发标记之后，会有重新标记阶段解决漏标问题，此时需要暂停用户线程。这些都完成后就知道了老年代有哪些存活对象，随后进入混合收集阶段。此时不会对所有老年代区域进行回收，而是根据暂停时间目标优先回收价值高（存活对象少）的区域（这也是 Gabage First 名称的由来）。

image.png

  1. 混合收集阶段中，参与复制的有 eden、survivor、old，下图显示了伊甸园和幸存区的存活对象复制

image.png

  1. 下图显示了老年代和幸存区晋升的存活对象的复制

image.png

  1. 复制完成，内存得到释放。进入下一轮的新生代回收、并发标记、混合收集

image.png

4. 内存溢出

要求

  • 能够说出几种典型的导致内存溢出的情况


4.1.误用线程池导致的内存溢出

情况一：
image.png
是由于任务数过多导致任务塞满导致OOM
改善：自定义BlockingQueue的大小
情况二：
image.png
同步队列：
image.png
是由于线程数没有上限，耗尽了系统的线程资源
改善：依然是自定义ThreadPoolExecutor

4.2.查询数据量太大导致的内存溢出

  1. import org.openjdk.jol.info.ClassLayout;
  3. import java.nio.charset.StandardCharsets;
  5. // 演示对象的内存估算
  6. public class TestOomTooManyObject {
  7.     public static void main(String[] args) {
  8.         // 对象本身内存
  9.         long a = ClassLayout.parseInstance(new Product()).instanceSize();
  10.         System.out.println(a);
  11.         // 一个字符串占用内存
  12.         String name = "联想小新Air14轻薄本 英特尔酷睿i5 14英寸全面屏学生笔记本电脑(i5-1135G7 16G 512G MX450独显 高色域)银";
  13.         long b = ClassLayout.parseInstance(name).instanceSize();
  14.         System.out.println(b);
  15.         String desc = "【全金属全面屏】学生商务办公，全新11代处理器，MX450独显，100%sRGB高色域，指纹识别，快充（更多好货）";
  16.         long c = ClassLayout.parseInstance(desc).instanceSize();
  17.         System.out.println(c);
  18.         System.out.println(16 + name.getBytes(StandardCharsets.UTF_8).length);
  19.         System.out.println(16 + desc.getBytes(StandardCharsets.UTF_8).length);
  20.         // 一个对象估算的内存
  21.         long avg = a + b + c + 16 + name.getBytes(StandardCharsets.UTF_8).length + 16 + desc.getBytes(StandardCharsets.UTF_8).length;
  22.         System.out.println(avg);
  23.         // ArrayList 24, Object[] 16 共 40
  24.         System.out.println((1_000_000 * avg + 40) / 1024 / 1024 + "Mb");
  25.     }
  27.     static public class Product {
  28.         private int id;
  29.         private String name;
  30.         private int price;
  31.         private String desc;
  33.         public int getId() {
  34.             return id;
  35.         }
  37.         public void setId(int id) {
  38.             this.id = id;
  39.         }
  41.         public String getName() {
  42.             return name;
  43.         }
  45.         public void setName(String name) {
  46.             this.name = name;
  47.         }
  49.         public int getPrice() {
  50.             return price;
  51.         }
  53.         public void setPrice(int price) {
  54.             this.price = price;
  55.         }
  57.         public String getDesc() {
  58.             return desc;
  59.         }
  61.         public void setDesc(String desc) {
  62.             this.desc = desc;
  63.         }
  64.     }
  65. }

当查询数据量过多时，容易导致OOM，所以尽量不要使用findAll()

4.3.动态生成类导致的内存溢出

  1. import groovy.lang.GroovyShell;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.util.concurrent.atomic.AtomicInteger;
  7. // -XX:MaxMetaspaceSize=24m
  8. // 模拟不断生成类, 但类无法卸载的情况
  9. public class TestOomTooManyClass {
  11. //    static GroovyShell shell = new GroovyShell();//类变量
  13.     public static void main(String[] args) {
  14.         AtomicInteger c = new AtomicInteger();
  15.         while (true) {
  16.             try (FileReader reader = new FileReader("script")) {
  17.                 GroovyShell shell = new GroovyShell();
  18.                 shell.evaluate(reader);
  19.                 System.out.println(c.incrementAndGet());
  20.             } catch (IOException e) {
  21.                 e.printStackTrace();
  22.             }
  23.         }
  24.     }
  25. }

元空间内存不足导致OOM
改善：让类变量变为局部变量，这样GC会不断触发来使得元空间不断获得新的内存。

5. 类加载

要求

  • 掌握类加载阶段
  • 掌握类加载器
  • 理解双亲委派机制

    5.1.类加载过程的三个阶段

  1. 加载
    1. 将类的字节码载入方法区，并创建类.class 对象
    2. 如果此类的父类没有加载，先加载父类
    3. 加载是懒惰执行（用到这个类时才会去加载）
  2. 链接
    1. 验证 – 验证类是否符合 Class 规范，合法性、安全性检查
    2. 准备 – 为 static 变量分配空间，设置默认值
    3. 解析 – 将常量池的符号引用解析为直接引用（在编译的时候一个每个java类都会被编译成一个class文件，但在编译的时候虚拟机并不知道所引用类的地址，所以就用符号引用来代替，而在解析阶段就是为了把这个符号引用转化成真正的地址的阶段。）
  3. 初始化
    1. 静态代码块、static 修饰的变量赋值、static final 修饰的引用类型变量赋值，会被合并成一个 方法，在初始化时被调用
    2. static final 修饰的基本类型变量赋值，在链接阶段就已完成
    3. 初始化是懒惰执行（用到这个类时才会去初始化）

验证手段

  • 使用 jps 查看进程号
  • 使用 jhsdb 调试，执行命令 jhsdb.exe hsdb 打开它的图形界面
    • Class Browser 可以查看当前 jvm 中加载了哪些类
    • 控制台的 universe 命令查看堆内存范围
    • 控制台的 g1regiondetails 命令查看 region 详情

image.png

  • scanoops 起始地址 结束地址 对象类型 可以根据类型查找某个区间内的对象地址
  • 控制台的 inspect 地址 指令能够查看这个地址对应的对象详情
    • 使用 javap 命令可以查看 class 字节码

image.png
以下代码说明：

  1. 使用 static final 修饰的基本类型不会触发类加载
  2. 使用 static final 修饰的引用类型会触发加载和初始化 ```java import java.io.IOException;

public class TestFinal { public static void main(String[] args) throws IOException { System.out.println(Student.c); // c 是 final static 基本类型 System.in.read();

  1.     System.out.println(Student.m); // m 是 final static 基本类型
  2.     System.in.read();
  4.     System.out.println(Student.n); // n 是 final static 引用类型
  5.     System.in.read();
  6. }

} ``` 知识补充：

1.符号引用：符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能够无歧义的定位到目标即可。 例如，在Class文件中它以CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info等类型的常量出现。符号引用与虚拟机的内存布局无关，引用的目标并不一定加载到内存中。在Java中，一个java类将会编译成一个class文件。在编译时，java类并不知道所引用的类的实际地址，因此只能使用符号引用来代替。比如org.simple.People类引用了org.simple.Language类，在编译时People类并不知道Language类的实际内存地址，因此只能使用符号org.simple.Language（假设是这个，当然实际中是由类似于CONSTANT_Class_info的常量来表示的）来表示Language类的地址。各种虚拟机实现的内存布局可能有所不同，但是它们能接受的符号引用都是一致的，因为符号引用的字面量形式明确定义在Java虚拟机规范的Class文件格式中。 2.直接引用，直接引用可以是： （1）直接指向目标的指针（比如，指向“类型”【Class对象】、类变量、类方法的直接引用可能是指向方法区的指针） （2）相对偏移量（比如，指向实例变量、实例方法的直接引用都是偏移量） （3）一个能间接定位到目标的句柄 直接引用是和虚拟机的布局相关的，同一个符号引用在不同的虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经被加载入内存中了。

5.2.jdk 8 的类加载器

名称 加载哪的类 说明
Bootstrap ClassLoader JAVA_HOME/jre/lib 无法直接访问
Extension ClassLoader JAVA_HOME/jre/lib/ext 上级为 Bootstrap，显示为 null
Application ClassLoader classpath 上级为 Extension
自定义类加载器 自定义 上级为 Application

双亲委派机制
所谓的双亲委派，就是指优先委派上级类加载器进行加载，如果上级类加载器

  • 能找到这个类，由上级加载，加载后该类也对下级加载器可见
  • 找不到这个类，则下级类加载器才有资格执行加载

双亲委派的目的有两点

  1. 让上级类加载器中的类对下级共享（反之不行），即能让你的类能依赖到 jdk 提供的核心类
  2. 让类的加载有优先次序，保证核心类优先加载

    5.3.对双亲委派的误解

    下面面试题的回答是错误的
    image.png
    错在哪了？
  • 自己编写类加载器就能加载一个假冒的 java.lang.System 吗? 答案是不行。
  • 假设你自己的类加载器用双亲委派，那么优先由启动类加载器加载真正的 java.lang.System，自然不会加载假冒的
  • 假设你自己的类加载器不用双亲委派，那么你的类加载器加载假冒的 java.lang.System 时，它需要先加载父类 java.lang.Object，而你没有用委派，找不到 java.lang.Object 所以加载会失败
  • 以上也仅仅是假设。事实上操作你就会发现，自定义类加载器加载以 java. 打头的类时，会抛安全异常，在 jdk9 以上版本这些特殊包名都与模块进行了绑定，更连编译都过不了