5.6 HotSpot和堆

5.6.1 Hotspot

三种JVM：

• Sun公司，Hotspot
• BEA，JRockit
• IBM，J9 VM，号称是世界上最快的Java虚拟机

我们一般学习的是：HotSpot

5.6.2 堆

Heap，一个JVM只有一个堆内存，堆内存的大小是可以调节的。

类加载器读取了类文件后，一般会把什么东西放到堆中？类、方法、常量、变量，保存我们所有引用类型的真实对象。

堆内存中还要细分为三个区域：

• 新生区（伊甸园区） Young/New
• 养老区 old
• 永久区 perm

5.7 新生区、永久区、堆内存调优

新生区：

• 类：诞生、成长、甚至死亡

• 伊甸园，所有的对象都是在伊甸园区new出来的

• 幸存者区（0，1）

老年区：

经过研究，99%的对象都是临时对象！

永久区：

• JDK1.6之前：永久代，常量池是在方法区；
• JDK1.7：永久代，慢慢退化了，去永久代，常量池在堆中；
• JDK1.8及之后：无永久代，常量池在元空间

5.8 JProfiler工具分析OOM原因

• 内存快照工具：MAT、JProfiler；

• MAT、JProfiler作用：

  • 分析Dump内存文件，快速定位内存泄露；
  • 获得堆中数据；
  • 获得大的对象

• 查看内存情况：

  VM options: -Xms1024m -Xmx1024m -XX:+PrintGCDetails
  可以查看：
  Heap
  PSYoungGen total 305664K, used 15729K [0x00000000eab00000, 0x0000000100000000, 0x0000000100000000)
  eden space 262144K, 6% used [0x00000000eab00000,0x00000000eba5c420,0x00000000fab00000)
  from space 43520K, 0% used [0x00000000fd580000,0x00000000fd580000,0x0000000100000000)
  to space 43520K, 0% used [0x00000000fab00000,0x00000000fab00000,0x00000000fd580000)
  ParOldGen total 699392K, used 0K [0x00000000c0000000, 0x00000000eab00000, 0x00000000eab00000)
  object space 699392K, 0% used [0x00000000c0000000,0x00000000c0000000,0x00000000eab00000)
  Metaspace used 3144K, capacity 4496K, committed 4864K, reserved 1056768K
  class space used 342K, capacity 388K, committed 512K, reserved 1048576K

  -Xms8m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
  测试代码：
  package com.hzs.basic.jvm;
  import java.util.ArrayList;

  /**

  • @Author Cherist Huan
  • @Date 2021/7/9 22:55
  • @Version 1.0
    */
    // -Xms1024m -Xmx1024m -XX:+HeapDumpOnOutOfMemoryError
    public class TestJprofiler {

  byte[] array = new byte[110241024];

  public static void main(String[] args) {

  ArrayList list = new ArrayList<>();
  int count = 0;

  while(true){

   list.add(new TestJprofiler());
   count++;
  

  }
  }
  }

  输出：
  java.lang.OutOfMemoryError: Java heap space
  Dumping heap to java_pid8092.hprof …
  Heap dump file created [984453445 bytes in 0.824 secs]
  Exception in thread “main” java.lang.OutOfMemoryError: Java heap space
  at com.hzs.basic.jvm.TestJprofiler.(TestJprofiler.java:13)
  at com.hzs.basic.jvm.TestJprofiler.main(TestJprofiler.java:22)

  Process finished with exit code 1

​

5.9 GC（垃圾回收）

​ JVM在进行GC时，并不是对这三个区域统一回收，大部分时候，回收都是新生代：

• 新生代
• 幸存区（from，to）
• 老年区

GC两种类型：轻GC（普通GC），重GC（全局GC、FullGC）

GC题目：

• JVM的内存模型和分区，详细到每个分区放什么？

• 堆里面的分区有哪些？说说它们的特点？

  • Eden，from,to，老年区

• GC算法有哪些？怎么用的？

  • 标记清除法、标记压缩、复制算法、引用计数法

• 轻GC和重GC分别在什么时候发生？

  • 轻GC（Minor GC）

  ​ 一般情况下，当新对象生成，并且在Eden申请空间失败时，就会触发Minor GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区，这种方式的GC是对年轻代的Eden区进行，不会影响到老年代。因为大部分对象都是从Eden区开始的，同时Eden区不会分配的很大，所以Eden区的GC会频繁进行。因而，一般在这里需要使用速度快、I效率高的算法，使Eden区能尽快空闲出来。

  • 重GC （Full GC）

  对整个堆进行整理，包括年轻代、老年代、持久代。Full GC因为需要对整个堆进行回收，所以比Minor GC要慢，因而应该尽可能减少Full GC的次数。在对JVM调优的过程中，很大一部分工作就是对Full GC的调节。有如下的原因可能导致Full GC:

  （1）老年代被写满；

  （2）持久代被写满；

  （3）System.gc()被显示调用；

  （4）上一次GC之后Heap的各域分配策略动态变化

• 为什么不是1块Survivor空间而是2块？

  分析：

  • 这里涉及到一个新生代和老年代的存活周期的问题，比如一个对象在新生代经历15次GC回收，就可以移到老年代了。
  • 问题来了，当我们第一次GC的时候，我们可以把Eden区的存活对象放到Survivor-1空间，但是第二次GC的时候，Survivor-1空间和Eden区的存活对象也需要再次用复制算法，放到Survivior-2空间上，而把刚刚的Survivor-1空间和Eden空间清除。第三次GC时，又把Survivor-2空间和Eden区的存活对象复制到Survivor-1空间，如此反复。
  • 所以，这里就需要2块Survivor空间来回倒腾。

• 为什么Eden空间这么大而Survivor空间要分的少一点？

  分析：

  • 新创建的对象都是放在Eden空间，这是很频繁的，尤其是大量的局部变量产生的临时对象，这些对象绝大部分都应该马上被回收，能存活下来被转移到survivior空间一般不是很多。所以，设置较大的Eden空间和较小的Survivor空间是合理的，大大提高了内存的使用率，缓解了复制算法的缺点。

  • 8：1:1这种比例就挺好的，当然这个比例是可以调整的，包括上面的新生代和老年代的1:2的比例也是可以调整的。

  • 从Eden空间往Survivor空间转移的时候，如果出现Survivor空间不够了怎么办？直接放到老年代去。如果老年代Old区也被放满了，就是一次大GC即为Major GC。

  • 有的对象来回在Survivor-1区或者Survivor-2区待了比如15次，就被分配到老年代Old区；
  • 有的对象太大，超过了Eden区，直接被分配到Old区；
  • 有的存活对象，放不下Survivor区，也被分配到Old区。

5.9.1 GC-（标记-清除）（引用计数法）

1. 流程

   主要分为“标记”和“清除”两个阶段：

   • （1）首先标记出所需要回收的对象（引用计数法和可达性分析，两次标记过程）；
   • （2）在标记完成后统一回收所有被标记的对象。

2. 缺点

   • （1）效率问题：标记和清除两个过程的效率不高；
   • （2）空间问题：标记清除后会产生大量不连续的内存碎片，导致以后在程序运行过程中需要分配较大对象时，无法找到足够的连续内存而不得不提前触发另一次垃圾收集工作。

5.9.2 GC-（复制）

1. 流程

   可以解决效率问题，将可用的内存按容量划分为大小相等的两块。

   • （1） 每次只使用其中的一块；
   • （2）当这一块用完了，就将还存活的对象复制到另一块上；
   • （3）然后再把已使用的内存空间清理掉。

2. 优点

   • 每次对整个半区进行内存回收，避免了内存碎片问题；
   • 只需移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。

3. 缺点

   • 将内存缩小为原来的一般，代价高；
   • 当对象存活率高时，需要进行较多的复制操作，效率降低。

4. 应用

   • 回收新生代，新生代中分为Eden空间和两块较小的Survivor空间，每次使用Eden和其中的一块Survivior。
   • 默认Eden：Survivor = 8:1 ，Survivor不够时，老年代内存分配担保。

5.9.3 GC-（标记-整理）

1. 流程

   • （1）首先标记出所需要回收的对象；
   • （2）不直接对可回收对象进行清理，让所有存活的对象都向一段移动；
   • （3）直接清理掉端边界以外的内存。

2. 优点

   改进了复制算法在对象存活率较高时带来的效率问题。

3. 应用

   老年代收集（对象存活率较高）

5.9.4 GC-（分代收集）

1. 思想

   根据对象存活周期的不同将内存划分为新生代和老年代，根据各自的特点采用合适的收集算法。

   • （1）新生代中，每次垃圾收集时都发现有大批对象死去，少量存活，用复制算法；
   • （2）老年代中，对象存活率高、没有额外空间进行分配担保，使用“标记-清理”或者“标记-整理”。

5.9.5 GC-总结

• 内存效率：复制算法 > 标记清除算法 > 标记压缩（整理）算法 （时间复杂度）
• 内存整齐度：复制算法 = 标记压缩（整理）算法 > 标记清除算法
• 内存利用率：标记压缩（整理）算法 = 标记清除算法 > 复制算法

没有最优的GC算法，只有最合适的算法----> GC：分代收集算法。

年轻代：

• 存活率低
• 复制算法

老年代：

• 区域大：存活率大
• 标记清除 + 标记压缩混合实现

5.10 JVM经典面试笔试题整理

题目1：简述JVM的内存结构，并解释每个区域的作用。

答案：

JVM的内存结构主要包括方法区、堆、栈（包括虚拟机栈和本地方法栈）和程序计数器。

• 方法区：存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
• 堆：是Java虚拟机所管理的内存中最大的一块，是所有线程共享的一块内存区域。它用于存放对象实例。
• 虚拟机栈：每个方法被执行的时候都会创建一个栈帧用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。
• 本地方法栈：与虚拟机栈所发挥的作用非常相似，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。
• 程序计数器：是一块较小的内存空间，可以看作是当前线程所执行的字节码的行号指示器。

题目2：什么是Java中的类加载器？它有什么作用？

答案：

Java中的类加载器（ClassLoader）负责加载类的二进制数据到JVM中，并转换成java.lang.Class类的实例。类加载器的主要作用是确保每个类的字节码被JVM加载时都是唯一的。Java提供了三种类加载器：启动类加载器（Bootstrap）、扩展类加载器（Extension）和系统类加载器（System）。此外，还可以自定义类加载器。类加载器采用双亲委派模型来加载类，这种模型可以保证Java核心类库的类型安全，防止应用程序随意替换核心类库中的类。

题目3：简述Java对象在JVM中的创建过程。

答案：

Java对象在JVM中的创建过程大致如下：

1. 类加载检查：当Java虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池的类符号表中找到一个与之对应的类符号引用，并且检查这个引用代表的类是否已被加载过、解析和初始化过。如果没有，那必须先执行相应的类加载过程。
2. 分配内存：在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定，为对象分配空间的任务等同于把一块确定大小的内存从Java堆中划分出来。
3. 初始化零值：内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），这一步保证了对象的实例字段在Java代码中可以不赋初值而直接使用，程序能访问到这些字段的数据类型所对应的零值。
4. 设置对象头：初始化零值完成之后，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象头中。
5. 执行init方法：在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从Java程序的视角来看，对象创建才刚开始，<init>方法还没有执行，所有的字段值都为零。所以一般来说，执行new指令之后会接着执行<init>方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。

题目4：解释双亲委派模型及其作用？

答案：
双亲委派模型是Java类加载器的一个重要特性，其工作原理是：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中。只有当父类加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载。

双亲委派模型的好处在于：

• 避免类的重复加载：当父类加载器已经加载了该类时，子类加载器就不会再加载。
• 保证Java的核心类的安全：防止核心类的篡改，即使是用户自定义的类加载器，也无法加载一个核心类。

题目5：谈谈JVM中的垃圾回收机制？

答案1：
JVM中的垃圾回收机制是自动内存管理的重要部分，它主要负责自动回收不再使用的对象所占用的内存。

垃圾回收主要依赖于两个基本算法：引用计数算法和可达性分析算法。现代JVM主要使用可达性分析算法来判断对象是否可回收。通过一系列称为GC Roots的根对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。

JVM提供了多种垃圾回收器，如Serial、Parallel、CMS、G1等，每种回收器都有其特点和适用场景。JVM会根据运行时的具体情况选择合适的垃圾回收器进行垃圾回收。

题目6：简述JVM中的栈内存溢出和堆内存溢出？

答案：

• 栈内存溢出（StackOverflowError）：通常是由于方法的递归调用没有正确的终止条件，导致无限递归调用，最终耗尽栈内存空间。此外，单个线程请求的栈深度大于虚拟机所允许的深度时，也会抛出StackOverflowError。

示例代码：

public class StackOverflowErrorDemo {  
    public static void main(String[] args) {  
        main(args); // 无限递归调用  
    }  
}

• 堆内存溢出（OutOfMemoryError）：通常是由于创建了大量的对象，并且GC无法回收足够的空间来满足新对象的分配需求。这可能是因为存在内存泄漏，或者堆的大小设置得太小，无法满足应用程序的需求。

示例代码（可能导致内存泄漏）：

import java.util.ArrayList;  
import java.util.List;  
  
public class OutOfMemoryErrorDemo {  
    static class Leaky {  
        public byte[] data = new byte[1024 * 1024]; // 1MB  
    }  
  
    public static void main(String[] args) {  
        List<Leaky> leakyList = new ArrayList<>();  
        while (true) {  
            leakyList.add(new Leaky()); // 不断创建新的对象并添加到列表中，但从未释放，导致内存泄漏  
        }

题目7：JVM内存区域划分及各自特点

题目描述：
请简述JVM的内存区域划分，并解释每个区域的特点。

答案：
JVM内存区域主要划分为以下几个部分：

1. 方法区（Method Area）：存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
2. 堆（Heap）：所有线程共享的一块内存区域，用于存放对象实例。堆内存按照分代收集算法又可以分为新生代和老年代。
3. 栈（Stack）：每个线程都有一个私有的栈，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。栈内存的生命周期与线程相同，随着线程的创建而创建，随着线程的销毁而销毁。
4. 程序计数器（Program Counter Register）：一块较小的内存空间，可以看作是当前线程所执行的字节码的行号指示器。字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。

题目8：双亲委派模型

题目描述：
请解释JVM类加载器中的双亲委派模型，并给出其优点。

答案：
双亲委派模型是JVM类加载器的一种加载机制，其工作原理如下：

1. 当一个类加载器需要加载一个类时，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成。
2. 每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中。
3. 只有当父类加载器无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载。

双亲委派模型的优点主要有：

1. 安全性：防止具有恶意的自定义加载器来篡改类的定义。
2. 避免重复加载：确保一个类的全局唯一性，即一个类只会被加载一次。

题目9：从Java源码到执行的过程

题目描述：
请简述从Java源码到执行的过程。

答案：
从Java源码到执行的过程大致如下：

1. 编写Java源码：使用文本编辑器编写Java源代码文件（.java）。
2. 编译：使用Java编译器（javac）将.java文件编译成字节码文件（.class）。
3. 类加载：JVM通过类加载器将.class文件加载到内存中，并生成对应的Class对象。
4. 解释执行：JVM的解释器逐行解释执行字节码指令，或者通过即时编译器（JIT）将热点代码编译成机器码直接执行。

题目10：JVM中的垃圾回收算法

题目描述：
请简述JVM中的垃圾回收算法及其特点。

答案：
JVM中的垃圾回收算法主要有以下几种：

1. 标记-清除（Mark-Sweep）算法：分为两个阶段，首先标记出所有需要回收的对象，然后统一回收被标记的对象。缺点是会产生内存碎片。
2. 复制（Copying）算法：将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。缺点是内存使用率不高。
3. 标记-整理（Mark-Compact）算法：标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
4. 分代收集（Generational Collection）算法：根据对象存活