Loading... # JVM 《Java虚拟机》第三版 [Java 全栈知识体系](https://www.pdai.tech/) [Java虚拟机(JVM)面试题（2020最新版）](https://thinkwon.blog.csdn.net/article/details/104390752) [JVM总结](https://github.com/duktig666/knowledge/blob/main/java/jvm/JVM%E6%80%BB%E7%BB%93.md) [JavaGuide](https://snailclimb.gitee.io/javaguide/) ## 一、Java内存区域 ### 1.1. JVM 的主要组成部分 <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211018142846.png" alt="img" style="zoom: 50%;" /> JVM包含两个子系统和两个组件，两个子系统为Class loader(类装载)、Execution engine(执行引擎)；两个组件为Runtime data area(运行时数据区)、Native Interface(本地接口)。 - Class loader(类装载)：根据给定的全限定名类名(如：java.lang.Object)来装载class文件到Runtime data area中的method area。 - Execution engine（执行引擎）：执行classes中的指令。 - Native Interface(本地接口)：与native libraries交互，是其它编程语言交互的接口。 - Runtime data area(运行时数据区域)：这就是我们常说的JVM的内存。 ### 1.2 Java程序运行机制详细说明 Java程序运行机制步骤 - 首先利用IDE集成开发工具编写Java源代码，源文件的后缀为.java； - 再利用编译器(javac命令)将源代码编译成字节码文件，字节码文件的后缀名为.class； - 运行字节码的工作是由解释器(java命令)来完成的。  从上图可以看，java文件通过编译器变成了.class文件，接下来类加载器又将这些.class文件加载到JVM中。 其实可以一句话来解释：类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class对象，用来封装类在方法区内的数据结构。 ### 1.3. 说一下 JVM 运行时数据区 **Java 虚拟机在执行 Java 程序的过程中会把它所管理的内存区域划分为若干个不同的数据区域**。这些区域都有各自的用途，以及创建和销毁的时间，有些区域随着虚拟机进程的启动而存在，有些区域则是依赖线程的启动和结束而建立和销毁。Java 虚拟机所管理的内存被划分为如下几个区域： <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211018143140.png" alt="img" style="zoom:50%;" /> 不同虚拟机的运行时数据区可能略微有所不同，但都会遵从 Java 虚拟机规范， Java 虚拟机规范规定的区域分为以下 5 个部分： - 程序计数器（Program Counter Register）：当前线程所执行的字节码的行号指示器，字节码解析器的工作是通过改变这个计数器的值，来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能，都需要依赖这个计数器来完成； - Java 虚拟机栈（Java Virtual Machine Stacks）：用于存储局部变量表、操作数栈、动态链接、方法出口等信息； - 本地方法栈（Native Method Stack）：与虚拟机栈的作用是一样的，只不过虚拟机栈是服务 Java 方法的，而本地方法栈是为虚拟机调用 Native 方法服的； - Java 堆（Java Heap）：Java 虚拟机中内存最大的一块，是被所有线程共享的，几乎所有的对象实例都在这里分配内存； - 方法区（Methed Area）：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数据。 **JDK 1.8 和之前的版本略有不同** 方法区与永久代的关系 > 《Java 虚拟机规范》只是规定了有方法区这么个概念和它的作用，并没有规定如何去实现它。那么，在不同的 JVM 上方法区的实现肯定是不同的了。 **方法区和永久代的关系很像 Java 中接口和类的关系，类实现了接口，而永久代就是 HotSpot 虚拟机对虚拟机规范中方法区的一种实现方式。** 也就是说，永久代是 HotSpot 的概念，方法区是 Java 虚拟机规范中的定义，是一种规范，而永久代是一种实现，一个是标准一个是实现，其他的虚拟机实现并没有永久代这一说法。 JDK8移出了永久代，改为元空间代替，为什么？ - 因为永久代有上限，导致Java应用更容易遇到内存溢出问题。而元空间使用的是直接内存，受本机可用内存的限制，虽然元空间仍旧可能移出，但是比原来出现的几率会更小 - 内存回收的目标主要针对 常量池的回收 和 类型的卸载。 <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211124165052.png" alt="image-20211124165052491" style="zoom: 67%;" /> **线程私有的：** - 程序计数器 - 虚拟机栈 - 本地方法栈 **线程共享的：** - 堆 - 方法区 - 直接内存 (非运行时数据区的一部分) ### 1.4. 深拷贝和浅拷贝 **浅拷贝（shallowCopy）**只是增加了一个指针指向已存在的内存地址， **深拷贝（deepCopy）**是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存， **使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。** **浅复制**：仅仅是指向被复制的内存地址，如果原地址发生改变，那么浅复制出来的对象也会相应的改变。 **深复制**：在计算机中开辟一块新的内存地址用于存放复制的对象。 ### 1.5. 说一下堆栈的区别？ #### 1.5.1. 物理地址 **堆**的物理地址分配对对象是不连续的。因此性能慢些。在GC的时候也要考虑到不连续的分配，所以有各种算法。比如，标记-消除，复制，标记-压缩，分代（即新生代使用复制算法，老年代使用标记——压缩） **栈**使用的是数据结构中的栈，先进后出的原则，物理地址分配是连续的。所以性能快。 #### 1.5.2. 内存分别 **堆**因为是不连续的，所以分配的内存是在运行期确认的，因此大小不固定。一般堆大小远远大于栈。 **栈**是连续的，所以分配的内存大小要在编译期就确认，大小是固定的。 #### 1.5.3. 存放的内容 **堆**存放的是对象的实例和数组。因此该区更关注的是数据的存储 **栈**存放：局部变量，操作数栈，返回结果。该区更关注的是程序方法的执行。 PS： - 静态变量放在方法区 - 静态的对象还是放在堆。 #### 1.5.4. 程序的可见度 **堆**对于整个应用程序都是共享、可见的。 **栈**只对于线程是可见的。所以也是线程私有。他的生命周期和线程相同。 ### 1.6. 队列和栈区别 队列和栈都是被用来预存储数据的。 - **操作的名称不同**。队列的插入称为入队，队列的删除称为出队。栈的插入称为进栈，栈的删除称为出栈。 - **可操作的方式不同**。队列是在队尾入队，队头出队，即两边都可操作。而栈的进栈和出栈都是在栈顶进行的，无法对栈底直接进行操作。 - **操作的方法不同**。队列是先进先出（FIFO），即队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（不能从中间插入），每次离开的成员总是队列头上（不允许中途离队）。而栈为后进先出（LIFO）,即每次删除（出栈）的总是当前栈中最新的元素，即最后插入（进栈）的元素，而最先插入的被放在栈的底部，要到最后才能删除。 ## 二、HotSpot虚拟机对象 ### 2.1. 对象的创建  说到对象的创建，首先让我们看看 Java 中提供的几种对象创建方式： | **Header** | **解释** | | ------------------------------------ | ------------------ | | 使用new关键字 | 调用了构造函数 | | 使用Class的newInstance方法 | 调用了构造函数 | | 使用Constructor类的newInstance方法 | 调用了构造函数 | | 使用clone方法 | 没有调用构造函数 | | 使用反序列化 | 没有调用构造函数 | 对象创建的主要流程: 1. **类加载。**虚拟机遇到一条new指令时，先检查常量池是否已经加载相应的类，如果没有，必须先执行相应的类加载。类加载通过后，接下来分配内存。 2. **分配内存。**若Java堆中内存是绝对规整的，使用“指针碰撞“方式分配内存；如果不是规整的，就从空闲列表中分配，叫做”空闲列表“方式。 3. **处理并发。**划分内存时还需要考虑一个问题-并发，也有两种方式: CAS同步处理，或者本地线程分配缓冲(Thread Local Allocation Buffer, TLAB)。 4. 然后内存空间初始化操作，接着是做一些必要的对象设置(元信息、哈希码…)，最后执行<init>方法。 #### 2.1.1. 类加载检查 虚拟机遇到一条 new 指令时，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有，那必须先执行相应的类加载过程。 #### 2.1.2. 为对象分配内存 类加载完成后，接着会在Java堆中划分一块内存分配给对象。内存分配根据Java堆是否规整，有两种方式： 1. **指针碰撞**：如果Java堆的内存是规整，即所有用过的内存放在一边，而空闲的的放在另一边。分配内存时将位于中间的指针指示器向空闲的内存移动一段与对象大小相等的距离，这样便完成分配内存工作。 2. **空闲列表**：如果Java堆的内存不是规整的，则需要由虚拟机维护一个列表来记录那些内存是可用的，这样在分配的时候可以从列表中查询到足够大的内存分配给对象，并在分配后更新列表记录。 选择哪种分配方式是由 Java 堆是否规整来决定的，而 Java 堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。 ##### 处理并发安全问题 对象的创建在虚拟机中是一个非常频繁的行为，哪怕只是修改一个指针所指向的位置，在并发情况下也是不安全的，可能出现正在给对象 A 分配内存，指针还没来得及修改，对象 B 又同时使用了原来的指针来分配内存的情况。解决这个问题有两种方案： 1. **同步处理**：对分配内存空间的动作进行同步处理（采用 CAS + 失败重试来保障更新操作的原子性）； 2. **本地线程分配缓冲**：把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在 Java 堆中预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer, TLAB）。哪个线程要分配内存，就在哪个线程的 TLAB 上分配。只有 TLAB 用完并分配新的 TLAB 时，才需要同步锁。通过-XX:+/-UserTLAB参数来设定虚拟机是否使用TLAB。 #### 2.1.3. 初始化零值 内存分配完成后，虚拟机需要将分配到的内存空间都**初始化为零值（不包括对象头）**，这一步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。 #### 2.1.4. 设置对象头 初始化零值完成之后，**虚拟机要对对象进行必要的设置**，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的 GC 分代年龄等信息。 这些信息存放在**对象头**中。 另外，根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。 #### 2.1.5 执行 init 方法 在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从 Java 程序的视角来看，对象创建才刚开始，`<init>` 方法还没有执行，所有的字段都还为零。所以一般来说，执行 new 指令之后会接着执行 `<init>` 方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。 ### 2.2. 对象的内存布局 在HotSpot虚拟机中，对象在内存中的布局可以分为3块区域：**对象头**，**实例数据**和**对齐填充** #### 2.2.1 对象头 1. 用于存储**对象自身的运行时数据**（哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等）。官方称这部分为“Mark Word”。 2. **类型指针**，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是那个类的实例。 3. 特殊情况：如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据，因为虚拟机可以通过普通 Java对象的元数据信息确定Java对象的大小，但是如果数组的长度是不确定的，将无法通过元数据中的 信息推断出数组的大小。  #### 2.2.2 实例数据 **实例数据部分是对象真正存储的有效信息**，也是在程序中所定义的各种类型的字段内容。 #### 2.2.3 对齐填充部分 **对齐填充部分不是必然存在的，也没有什么特别的含义，仅仅起占位作用。** 因为 Hotspot 虚拟机的自动内存管理系统要求对象起始地址必须是 8 字节的整数倍，换句话说就是对象的大小必须是 8 字节的整数倍。而对象头部分正好是 8 字节的倍数（1 倍或 2 倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。 ### 2.3. 对象的访问定位 ``` Java程序需要通过 JVM 栈上的引用访问堆中的具体对象。对象的访问方式取决于 JVM 虚拟机的实现。目前主流的访问方式有 ``` **句柄** 和 **直接指针** 两种方式。 ``` ``` **指针：** 指向对象，代表一个对象在内存中的起始地址。 ``` ``` **句柄：** 可以理解为指向指针的指针，维护着对象的指针。句柄不直接指向对象，而是指向对象的指针（句柄不发生变化，指向固定内存地址），再由对象的指针指向对象的真实内存地址。 #### 2.3.1. 句柄访问 Java堆中划分出一块内存来作为**句柄池**，引用中存储对象的**句柄地址**，而句柄中包含了**对象实例数据**与**对象类型数据**各自的**具体地址**信息，具体构造如下图所示： <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211124171033.png" alt="img" style="zoom: 67%;" /> **优势**：引用中存储的是**稳定**的句柄地址，在对象被移动（垃圾收集时移动对象是非常普遍的行为）时只会改变**句柄中**的**实例数据指针**，而**引用**本身不需要修改 #### 2.3.2. 直接指针 如果使用**直接指针**访问，**引用** 中存储的直接就是**对象地址**，那么Java堆对象内部的布局中就必须考虑如何放置访问**类型数据**的相关信息。 <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211124171027.png" alt="img" style="zoom:67%;" /> **优势**：速度更**快**，节省了**一次指针定位**的时间开销。由于对象的访问在Java中非常频繁，因此这类开销积少成多后也是非常可观的执行成本。HotSpot 中采用的就是这种方式。 ## 三、内存溢出异常 ### 3.1. Java会存在内存泄漏吗？ ``` ``` **内存泄漏是指不再被使用的对象或者变量一直被占据在内存中**。理论上来说，Java是有GC垃圾回收机制的，也就是说，不再被使用的对象，会被GC自动回收掉，自动从内存中清除。 ``` 但是，即使这样， ``` **Java也还是存在着内存泄漏的情况**，java导致内存泄露的原因很明确：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景。 ## 四、 垃圾回收 ### 4.1. 简述Java垃圾回收机制 ``` 在java中，程序员是不需要显式的去释放一个对象的内存的，而是由虚拟机自行执行。 ``` **在JVM中，有一个垃圾回收线程，它是低优先级的，在正常情况下是不会执行的，只有在虚拟机空闲或者当前堆内存不足时，才会触发执行，扫面那些没有被任何引用的对象，并将它们添加到要回收的集合中，进行回收。** ### 4.2. GC是什么？为什么要GC ``` ``` **GC 是垃圾收集的意思（Gabage Collection）**，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java 提供的 GC 功能可以自动监测对象是否超过作用域从而达到自动 回收内存的目的，Java 语言没有提供释放已分配内存的显示操作方法。 ### 4.3. 垃圾回收的优点及回收机制 #### 4.3.1. 优点： 1. Java语言最显著的特点就是引入了垃圾回收机制，它使java程序员在编写程序时不再考虑内存管理的问题。 2. 由于有这个垃圾回收机制，java中的对象不再有“作用域”的概念，只有引用的对象才有“作用域”。 3. 垃圾回收机制有效的防止了内存泄露，可以有效的使用可使用的内存。 4. 垃圾回收器通常作为一个单独的低级别的线程运行，在不可预知的情况下对内存堆中已经死亡的或很长时间没有用过的对象进行清除和回收。 5. 程序员不能实时的对某个对象或所有对象调用垃圾回收器进行垃圾回收。 #### 4.3.2. 回收机制 ``` 垃圾回收有分代复制垃圾回收、标记垃圾回收、增量垃圾回收。 ``` **部分收集（Partial GC）** ``` 不完全收集Java堆中的垃圾，分为新生代收集、老年代收集和混合收集 ``` - 新生代收集（Minor GC）：只回收新生代的垃圾; - 老年代收集（Major GC）：只回收老年代的垃圾，但是目前仅有CMS GC有单独收集老年代垃圾的行为，很多时候Major GC和Full GC会混淆，需要分辨是老年代还是整堆垃圾回收 - 混合收集（Mixed GC）：收集整个新生代以及部分老年代的垃圾，目前只有G1 和GC会这样 **整堆收集（Full GC）** - 收集整个Java堆和方法区的垃圾 ### 4.4. 垃圾回收器的基本原理 1. 对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，**GC采用有向图的方式记录和管理堆(heap)中的所有对象**。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。 2. 程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。 ### 4.5. Java 引用类型 - 强引用：发生 gc 的时候不会被回收。 - 软引用：有用但不是必须的对象，在发生内存溢出之前会被回收。 - 弱引用：有用但不是必须的对象，在下一次GC时会被回收。 - 虚引用（幽灵引用/幻影引用）：无法通过虚引用获得对象，用 jdk1.2PhantomReference 实现虚引用，虚引用的用途是在 gc 时返回一个通知。 ### 4.6. 判断对象是否可以被回收 垃圾收集器在做垃圾回收的时候，首先需要判定的就是哪些内存是需要被回收的，哪些对象是「存活」的，是不可以被回收的；哪些对象已经「死掉」了，需要被回收。 一般有两种方法来判断： #### 4.6.1 引用计数器法： 为每个对象创建一个引用计数，有对象引用时计数器 +1，引用被释放时计数 -1，当计数器为 0 时就可以被回收。 1. 需要单独的字段存储计数器，增加了存储空间的开销； 2. 每次赋值都需要更新计数器，增加了时间开销； 3. 垃圾对象便于辨识，只要计数器为0，就可作为垃圾回收； 4. 及时回收垃圾，没有延迟性； 5. 不能解决循环引用的问题； #### 4.6.2 可达性分析算法： 从 GC Roots 开始向下搜索，搜索所走过的路径称为引用链。当一个对象到 GC Roots 没有任何引用链相连时，则证明此对象是可以被回收的。  **可作为 GC Roots 的对象**： - **在虚拟机栈（栈帧中的本地变量表）中引用的对象**，譬如各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。 - **在方法区中类静态属性引用的对象**，譬如Java类的引用类型静态变量。 - **在方法区中常量引用的对象**，譬如字符串常量池（String Table）里的引用。 - **在本地方法栈中JNI（即通常所说的Native方法）引用的对象**。 - **Java虚拟机内部的引用**，如基本数据类型对应的Class对象，一些常驻的异常对象（比如NullPointExcepiton、OutOfMemoryError）等，还有系统类加载器。 - **所有被同步锁（synchronized关键字）持有的对象**。 - **反映Java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等**。 **利用可达性分析算法，如何判断一个对象死亡**？ ``` 即使在可达性分析算法中判定为不可达的对象，也不是“非死不可”的，这时候它们暂时还处于**“缓刑”阶段**，要真正宣告一个对象死亡，至少要经历两次标记过程。 ``` - 第一次标记：对象没有与`GC Roots`相连时，判断该对象的`finalize`方法有没有被覆盖过，或者有没有被虚拟机执行过。如果没有，则直接被回收；如果执行过，对象被放置进`F-Queue`队列中，进行第二次标记。 - 第二次标记：如果对象在`finalize`关联上了`GC Roots`，在队列中移除（只能关联一次）；如果没有，被回收。 ### 4.7. Java对象被垃圾回收前提 ``` 一般情况下Java中对象可被回收的前提是：该对象不再被引用，然后垃圾回收器在回收的时候便会把这个对象清理掉。 ``` ### 4.8. 永久代中会发生垃圾回收吗 ``` 垃圾回收不会发生在永久代，如果永久代满了或者是超过了临界值，会触发完全垃圾回收(Full GC)。如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回收的。这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。请参考下Java8：从永久代到元数据区 ``` **(译者注：Java8中已经移除了永久代，新加了一个叫做元数据区的native内存区)** ### 4.9. JVM 垃圾回收算法 1. **标记-清除算法**：标记无用对象，然后进行清除回收。缺点：效率不高，无法清除垃圾碎片。 2. **复制算法**：按照容量划分二个大小相等的内存区域，当一块用完的时候将活着的对象复制到另一块上，然后再把已使用的内存空间一次清理掉。缺点：内存使用率不高，只有原来的一半。 3. **标记-整理算法**：标记无用对象，让所有存活的对象都向一端移动，然后直接清除掉端边界以外的内存。 4. **分代算法**：根据对象存活周期的不同将内存划分为几块，一般是新生代和老年代，新生代基本采用复制算法，老年代采用标记整理算法。 #### 4.9.1. 标记-清除算法 标记无用对象，然后进行清除回收。**在CMS回收器中用于老年代** 标记-清除算法（Mark-Sweep）是一种常见的基础垃圾收集算法，它将垃圾收集分为两个阶段： 1. 标记阶段：标记出可以回收的对象。 2. 清除阶段：回收被标记的对象所占用的空间。 **标记-清除算法之所以是基础的，是因为后面讲到的垃圾收集算法都是在此算法的基础上进行改进的。** **优点**：实现简单，不需要对象进行移动。 **缺点：** 1. 标记、清除过程效率低； 2. 产生大量不连续的内存碎片，可能会导致以后在程序运行过程中需要分配较大对象时无法找到足够的连续内存而不得不触发另一次垃圾收集，造成了垃圾回收的频率提高。 <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211124172003.png" alt="img" style="zoom:50%;" /> #### 4.9.2. 复制算法 为了解决标记-清除算法的效率不高的问题，产生了复制算法。它把内存空间划为两个相等的区域，每次只使用其中一个区域。垃圾收集时，遍历当前使用的区域，把存活对象复制到另外一个区域中，最后将当前使用的区域的可回收的对象进行回收。 **一般用于新生代** **优点**：按顺序分配内存即可，实现简单、运行高效，不用考虑内存碎片。 **缺点**：可用的内存大小缩小为原来的一半，对象存活率高时会频繁进行复制。优化：Apple式回收 复制算法的执行过程如下图所示 <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211124172012.png" alt="img" style="zoom:50%;" /> #### 4.9.3. 标记-整理算法 在新生代中可以使用复制算法，但是在老年代就不能选择复制算法了，因为老年代的对象存活率会较高，这样会有较多的复制操作，导致效率变低。标记-清除算法可以应用在老年代中，但是它效率不高，在内存回收后容易产生大量内存碎片。因此就出现了一种标记-整理算法（Mark-Compact）算法，与标记-整理算法不同的是，在标记可回收的对象后将所有存活的对象压缩到内存的一端，使他们紧凑的排列在一起，然后对端边界以外的内存进行回收。回收后，已用和未用的内存都各自一边。 **一般用于老年代** **优点**：解决了标记-清理算法存在的内存碎片问题。 **缺点**：仍需要进行局部对象移动，一定程度上降低了效率。 标记-整理算法的执行过程如下图所示 <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211124172035.png" alt="img" style="zoom:50%;" /> #### 4.9.4. 分代收集算法 ``` 当前商业虚拟机都采用 ``` **分代收集**的垃圾收集算法。分代收集算法，顾名思义是根据对象的**存活周期**将内存划分为几块。一般包括**年轻代**、**老年代** 和 **永久代**，新生代基本采用复制算法，老年代采用标记整理算法。 ## 五、JVM 垃圾回收器 ``` 如果说垃圾收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。下图展示了7种作用于不同分代的收集器，其中用于回收新生代的收集器 包括Serial、PraNew、Parallel Scavenge，回收老年代的收集器包括Serial Old、Parallel Old、CMS，还有用于回收整个Java堆的G1收集器。不同收集器之间的连线表示它们可以搭配使用。 ``` <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211124172814.png" alt="img" style="zoom:80%;" />  1. **Serial收集器（复制算法):** 新生代单线程收集器，标记和清理都是单线程，优点是简单高效，额外消耗内存小；缺点是单线程的意义并不仅仅是说明它只会使用一个处理器或一条收集线程去完成垃圾收集工作，更重要的是强调在它进行垃圾收集时，必须暂停其他工作线程知道它收集结束。； 2. **ParNew收集器 (复制算法):** 新生代并行收集器，实际上是Serial收集器的多线程版本，在多核CPU环境下有着比Serial更好的表现； 3. **Parallel Scavenge收集器 (复制算法):** 新生代并行收集器，追求高吞吐量，高效利用 CPU。吞吐量 = 用户线程时间/(用户线程时间+GC线程时间)，高吞吐量可以高效率的利用CPU时间，尽快完成程序的运算任务，适合后台应用等对交互相应要求不高的场景； 4. **Serial Old收集器 (标记-整理算法):** 老年代单线程收集器，Serial收集器的老年代版本； 5. **Parallel Old收集器 (标记-整理算法)：** 老年代并行收集器，吞吐量优先，Parallel Scavenge收集器的老年代版本； 6. **CMS(Concurrent Mark Sweep)收集器（标记-清除算法）：** 老年代并行收集器，以获取最短回收停顿时间为目标的收集器，具有高并发、低停顿的特点，追求最短GC回收停顿时间。 7. **G1(Garbage First)收集器 (标记-整理算法)：** Java堆并行收集器，G1收集器是JDK1.7提供的一个新收集器，G1收集器基于“标记-整理”算法实现，也就是说不会产生内存碎片。此外，G1收集器不同于之前的收集器的一个重要特点是：G1回收的范围是整个Java堆(包括新生代，老年代)，而前六种收集器回收的范围仅限于新生代或老年代。 ### 5.1 Serial收集器 #### 5.1.1 优点 - 与其他单线程垃圾收集器相比**简单高效** - 对于内存受限的环境，额外**内存消耗最小** - 对于单核或者核心数较少的环境来说，其没有线程交互开销，专心做垃圾收集**可以获得最高的单线程收集效率** #### 5.1.2 使用场景 Serial收集器对于运行在**客户端模式下的虚拟机**来说是一个很好的选择。 > 在用户桌面的应用场景以及近年来流行的部分微服务应用中，分配给虚拟机管理的内存一般来说并不会特别大，收集几十兆甚至一两百兆的新生代（仅仅是指新生代使用的内存，桌面应用甚少超过这个容量），垃圾收集的停顿时间完全可以控制在十几、几十毫秒，最多一 > 百多毫秒以内，只要不是频繁发生收集，这点停顿时间对许多用户来说是完全可以接受的。 Serial/Serial Old收集器运行示意图：  ### 5.2 ParNew收集器 - 实质上时Serial收集器的多线程并行版本 - 是激活CMS后（使用-XX：+UseConcMarkSweepGC选项）的默认新生代收集器。 - **JDK9以前ParNew + CMS 适用于 服务端模式下的垃圾收集器组合**。 ParNew/Serial Old收集器运行示意图：  ### 5.3 Parallel Scavenge收集器 #### 5.3.1 特点 - CMS等收集器的关注点是尽可能地缩短垃圾收集时用户线程的停顿时间， - Parallel Scavenge收集器的目标则是**达到一个可控制的吞吐量**（Throughput）。 所谓吞吐量就是处理器用于运行用户代码的时间与处理器总消耗时间的比值。 ``` 停顿时间越短就越适合需要与用户交互或需要保证服务响应质量的程序，良好的响应速度能提升用户体验；而高吞吐量则可以最高效率地利用处理器资源，尽快完成程序的运算任务， ``` **主要适合在后台运算而不需要太多交互的分析任务。** #### 5.3.2 参数 **Parallel Scavenge收集器提供了两个参数用于精确控制吞吐量**，分别是控制最大垃圾收集停顿时间的`-XX：MaxGCPauseMillis`参数以及直接设置吞吐量大小的`XX：GCTimeRatio`参数。 **-XX：MaxGCPauseMillis参数允许的值是一个大于0的毫秒数，收集器将尽力保证内存回收花费的时间不超过用户设定值**。垃圾收集停顿时间缩短是以牺牲吞吐量和新生代空间为代价换取的：系统把新生代调得小一些，收集300MB新生代肯定比收集500MB快，但这也直接导致垃圾收集发生得更频繁，原来10秒收集一次、每次停顿100毫秒，现在变成5秒收集一次、每次停顿70毫秒。停顿时间的确在下降，但吞吐量也降下来了。 -XX：GCTimeRatio参数的值则应当是一个大于0小于100的整数，也就是垃圾收集时间占总时间的比率，相当于吞吐量的倒数。譬如把此参数设置为19，那允许的最大垃圾收集时间就占总时间的5%，即1/(1+19)），默认值为99，即允许最大1%（即1/(1+99)）的垃圾收集时间。 Parallel Scavenge/Parallel Old收集器运行示意图：  ### 5.4 Serial Old收集器 Serial Old是Serial收集器的老年代版本。 使用场景： 这个收集器的主要意义也是供客户端模式下的HotSpot虚拟机使用 如果在服务端模式下，它也可能有两种用途： 1. 在JDK 5以及之前的版本中与Parallel Scavenge收集器搭配使用 2. 作为CMS收集器发生失败时的后备预案，在并发收集发生Concurrent Mode Failure时使用。 ### 5.5 Parallel Old收集器 Parallel Old是Parallel Scavenge收集器的老年代版本。 直到Parallel Old收集器出现后，“吞吐量优先”收集器终于有了比较名副其实的搭配组合，**在注重吞吐量或者处理器资源较为稀缺的场合，都可以优先考虑Parallel Scavenge / Parallel Old收集器这个组合**。 ### 5.6 CMS收集器 #### 5.6.1 特点 **CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器**。这是因为CMS收集器工作时，GC工作线程与用户线程可以`并发`执行，以此来达到降低收集停顿时间的目的。 #### 5.6.2 使用场景 集中在 **互联网网站或者基于浏览器的B/S系统的服务端** 上，这类应用通常都会较为关注服务的响应速度，希望系统停顿时间尽可能短，以给用户带来良好的交互体验。 #### 5.6.3 运作过程 CMS收集器仅作用于**老年代**的收集，是基于`标记-清除算法`的，它的运作过程分为4个步骤： 1. **初始标记（CMS initial mark）**：仅仅只是**标记一下GC Roots能直接关联到的对象**，速度很快，需要“Stop The World”。 2. **并发标记（CMS concurrent mark）**：是**从GC Roots的直接关联对象开始遍历整个对象图的过程**，这个过程耗时较长但是不需要停顿用户线程，可以与垃圾收集线程一起并发运行。 3. **重新标记（CMS remark）**：为了**修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录**，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但远比并发标记的时间短。此阶段也需要“Stop The World”。 4. **并发清除（CMS concurrent sweep）**：**清理删除掉标记阶段判断的已经死亡的对象**。由于不需要移动存活对象，所以这个阶段也是可以与用户线程同时并发的 CMS以流水线方式拆分了收集周期，**将耗时长的操作单元保持与应用线程并发执行**。只将那些必需STW才能执行的操作单元单独拎出来，控制这些单元在恰当的时机运行，并能保证仅需短暂的时间就可以完成。这样，在整个收集周期内，只有**两次短暂的暂停（初始标记和重新标记）**，**达到了近似并发的目的**。 #### 5.6.4 运行示意图 由于整个过程中耗时最长的并发标记和并发清除过程收集器线程都可以与用户线程一起工作。所以，从总体上来说，CMS收集器的内存回收过程是与用户线程一起并发执行的。通过下图可以比较清楚地看到CMS收集器的运作步骤中并发和需要停顿的时间：  #### 5.6.5 优缺点 **优点：** 并发收集、低停顿。 **缺点：** - **CMS收集器对CPU资源非常敏感**。面向并发设计的程序都对CPU资源比较敏感。在并发阶段，它虽然不会导致用户线程停顿，但会因为占用了一部分线程（或者说CPU资源）而导致应用程序变慢，总吞吐量会降低。 - **CMS收集器无法处理浮动垃圾（Floating Garbage）**。 - 由于**CMS并发清除阶段用户线程还在运行着，伴随程序运行自然就还会有新的垃圾不断产生**。这一部分垃圾出现在标记过程之后，CMS无法再当次收集中处理掉它们，只好留待下一次GC时再清理掉。 - 这一部分垃圾就被称为“浮动垃圾”。也是由于在垃圾收集阶段用户线程还需要运行，那也就还需要预留有足够的内存空间给用户线程使用，因此CMS收集器不能像其他收集器那样等到老年代几乎完全被填满了再进行收集，需要预留一部分空间提供并发收集时的程序运作使用。 - **CMS收集器是基于标记-清除算法，收集结束时可能存在大量空间碎片**。碎片过多时，将会给大对象分配带来很大麻烦，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象（所以未提供CMS的新生代版本）。 ### 5.7 Garbage First收集器（G1） #### 5.7.1 简介 Garbage First（简称G1）收集器是垃圾收集器技术发展历史上的里程碑式的成果，它开创了**收集器面向局部收集的设计思路**和**基于Region的内存布局形式**。 G1是一款主要面向服务端应用的垃圾收集器。 G1 GC切分堆内存为多个区间（Region），从而避免很多GC操作在整个Java堆或者整个年轻代进行。G1 GC只关注你有没有存货对象，都会被回收并放入可用的Region队列。G1 GC是基于Region的GC，**适用于大内存机器。即使内存很大，Region扫描，性能还是很高的**。 > JDK 9发布之日，G1宣告取代Parallel Scavenge加Parallel Old组合，成为服务端模式下的默认垃圾收集器，而CMS则沦落至被声明为不推荐使用（Deprecate）的收集器。如果对JDK 9及以上版本的HotSpot虚拟机使用参数 `-XX：+UseConcMarkSweepGC` 来开启CMS收集器的话，用户会收到一个警告信息，提示CMS未来将会被废弃： #### 5.7.2 特点 - **并行与并发**：G1能充分利用多CPU、多核环境下的硬件优势，使用多个CPU来缩短Stop-the-world停顿的时间，部分其他收集器原来需要停顿Java线程执行的GC操作，G1收集器仍然可以通过**并发**的方式让Java程序继续运行。 - 分代收集：G1能够自己管理不同分代内已创建对象和新对象的创建 - 空间整合：与CMS的标记-清除算法不同，G1从整体来看是基于**标记-整理算法**实现的收集器，从局部（两个Region之间）上来看是基于“**复制**”算法实现的。但无论如何，这两种算法都意味着G1运作期间不会产生内存空间碎片，收集后能提供规整的可用内存。**这种特性有利于程序长时间运行，分配大对象时不会因为无法找到连续内存空间而提前触发下一次GC**。 - 可预测的停顿：这是G1相对于CMS的一个优势，降低停顿时间是G1和CMS共同的关注点。 #### 5.7.3 目标 作为CMS收集器的替代者和继承人，设计者们希望做出一款能够建立起**“停顿时间模型”**（PausePrediction Model）的收集器，**停顿时间模型的意思是能够支持指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间大概率不超过N毫秒这样的目标**，这几乎已经是实时Java（RTSJ）的中软实时垃圾收集器特征了。 #### 5.7.4 目标实现 1. 首先要有一个思想上的改变 在G1收集器出现之前的所有其他收集器，包括CMS在内，垃圾收集的目标范围要么是整个新生代（Minor GC），要么就是整个老年代（Major GC），再要么就是整个Java堆（Full GC）。 而G1跳出了这个樊笼，它可以**面向堆内存任何部分来组成回收集（Collection Set，一般简称CSet）进行回收**，衡量标准不再是它属于哪个分代，而是哪块内存中存放的垃圾数量最多，回收收益最大，这就是G1收集器的**Mixed GC模式**。 2. G1开创的**基于Region的堆内存布局**是它能够实现这个目标的关键 虽然G1也仍是遵循分代收集理论设计的，但其堆内存的布局与其他收集器有非常明显的差异： **G1不再坚持固定大小以及固定数量的分代区域划分，而是把连续的Java堆划分为多个大小相等的独立区域（Region），每一个Region都可以根据需要，扮演新生代的Eden空间、Survivor空间，或者老年代空间**。收集器能够对扮演不同角色的Region采用不同的策略去处理，这样无论是新创建的对象还是已经存活了一段时间、熬过多次收集的旧对象都能获取很好的收集效果。 Region中还有一类特殊的Humongous区域，专门用来存储大对象。**G1认为只要大小超过了一个Region容量一半的对象即可判定为大对象**。 每个Region的大小可以通过参数`-XX：G1HeapRegionSize`设定，取值范围为1MB～32MB，且应为2的N次幂。而对于那些超过了整个Region容量的超级大对象，将会被存放在N个连续的Humongous Region之中，G1的大多数行为都把Humongous Region作为老年代的一部分来进行看待。 **3.建立可预测的停顿时间模型** 将Region作为单次回收的最小单元，即每次收集到的内存空间都是Region大小的整数倍，这样可以**有计划地避免在整个Java堆中进行全区域的垃圾收集**。 具体的处理思路： ``` 让G1收集器去跟踪各个Region里面的垃圾堆积的“价值”大小，价值即回收所获得的空间大小以及回收所需时间的经验值，然后在后台维护一个优先级列表，每次根据用户设定允许的收集停顿时间（使用参数-XX：MaxGCPauseMillis指定，默认值是200毫秒），优先处理回收价值收益最大的那些Region，这也就是“Garbage First”名字的由来。这种使用Region划分内存空间，以及具有优先级的区域回收方式，保证了G1收集器在有限的时间内获取尽可能高的收集效率。 ``` #### 5.7.5 运作过程 如果我们不去计算用户线程运行过程中的动作（如使用写屏障维护记忆集的操作），G1收集器运作过程大致可划分为以下四个步骤： 1. **初始标记（Initial Marking）**：**仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS指针的值，让下一阶段用户线程并发运行时，能正确地在可用的Region中分配新对象**。这个阶段需要停顿线程，但耗时很短，而且是借用进行Minor GC的时候同步完成的，所以G1收集器在这个阶段实际并没有额外的停顿。 2. **并发标记（Concurrent Marking）**：**从GC Root开始对堆中对象进行可达性分析，递归扫描整个堆里的对象图，找出要回收的对象**。这阶段耗时较长，但可与用户程序并发执行。当对象图扫描完成以后，还要重新处理SATB记录下的在并发时有引用变动的对象。 3. **最终标记（Final Marking）**：**对用户线程做另一个短暂的暂停，用于处理并发阶段结束后仍遗留下来的最后那少量的SATB记录**。 4. **筛选回收（Live Data Counting and Evacuation）**：**负责更新Region的统计数据，对各个Region的回收价值和成本进行排序，根据用户所期望的停顿时间来制定回收计划，可以自由选择任意多个Region构成回收集，然后把决定回收的那一部分Region的存活对象复制到空的Region中，再清理掉整个旧Region的全部空间。**这里的操作涉及存活对象的移动，是必须暂停用户线程，由多条收集器线程并行完成的。 G1收集器运行示意图：  #### 5.7.6 CMS和G1的区别 **区别一： 使用范围不一样** CMS收集器是老年代的收集器，可以配合新生代的Serial和ParNew收集器一起使用 G1收集器收集范围是老年代和新生代。不需要结合其他收集器使用 **区别二： STW的时间** CMS收集器以最小的停顿时间为目标的收集器。 G1收集器可预测垃圾回收的停顿时间（建立可预测的停顿时间模型） **区别三： 垃圾碎片** CMS收集器是使用“标记-清除”算法进行的垃圾回收，容易产生内存碎片 G1收集器使用的是“标记-整理”算法，进行了空间整合，降低了内存空间碎片。 **区别四： 垃圾回收的过程不一样** CMS收集器 G1收集器 1. 初始标记 1. 初始标记 2. 并发标记 2. 并发标记 3. 重新标记 3. 最终标记 4. 并发清除 4. 筛选回收 #### 5.7.7 优缺点 **G1的优势**： 1. 最大停顿时间、分Region的内存布局、按收益动态确定回收集这些创新性设计带来的优势 2. 算法层面的优势 与CMS的“标记-清除”算法不同，G1从整体来看是基于“标记-整理”算法实现的收集器，但从局部（两个Region之间）上看又是基于“标记-复制”算法实现，无论如何，这两种算法都意味着**G1运作期间不会产生内存空间碎片，垃圾收集完成之后能提供规整的可用内存**。 这种特性有利于程序长时间运行，在程序为大对象分配内存时不容易因无法找到连续内存空间而提前触发下一次收集 **G1的弱势**： 在用户程序运行过程中，G1无论是为了垃圾收集产生的内存占用（Footprint）还是程序运行时的额外执行负载（Overload）都要比CMS要高。 - **就内存占用来说** 虽然G1和CMS都使用卡表来处理跨代指针，但G1的卡表实现更为复杂，而且堆中每个Region，无论扮演的是新生代还是老年代角色，都必须有一份卡表，这导致G1的记忆集（和其他内存消耗）可能会占整个堆容量的20%乃至更多的内存空间；相比起来CMS的卡表就相当简单，只有唯一一份，而且只需要处理老年代到新生代的引用，反过来则不需要，由于新生代的对象具有朝生夕灭的不稳定性，引用变化频繁，能省下这个区域的维护开销是很划算的。 - **在执行负载的角度** 同样由于两个收集器各自的细节实现特点导致了用户程序运行时的负载会有不同，譬如它们都使用到写屏障，CMS用写后屏障来更新维护卡表；而G1除了使用写后屏障来进行同样的（由于G1的卡表结构复杂，其实是更烦琐的）卡表维护操作外，为了实现原始快照搜索（SATB）算法，还需要使用写前屏障来跟踪并发时的指针变化情况。相比起增量更新算法，原始快照搜索能够减少并发标记和重新标记阶段的消耗，避免CMS那样在最终标记阶段停顿时间过长的缺点，但是在用户程序运行过程中确实会产生由跟踪引用变化带来的额外负担。由于G1对写屏障的复杂操作要比CMS消耗更多的运算资源，所以CMS的写屏障实现是直接的同步操作，而G1就不得不将其实现为类似于消息队列的结构，把写前屏障和写后屏障中要做的事情都放到队列里，然后再异步处理。 ### 5.8 低延迟的垃圾收集器 垃圾收集器的三项重要指标：**内存占用、吞吐量、延迟**。 **内存的扩大，对低延迟反而会带来负面效果**：虚拟机要回收完整的1TB的堆内存，要比回收1GB的堆内存耗费更多的时间。 - CMS和G1分别使用增量更新和原始快照技术，实现了标记阶段的并发，不会因管理的堆内存变大，要标记的对象变多而导致停顿时间随之增长。但是对于标记阶段之后的处理，仍未得到妥善解决。 - CMS使用标记-清除算法，虽然避免了整理阶段收集器带来的停顿，但是清除算法不论如何优化改进，在设计原理上避免不了空间碎片的产生，随着空间碎片不断淤积最终依然逃不过“Stop TheWorld”的命运。 - G1虽然可以按更小的粒度进行回收，从而抑制整理阶段出现时间过长的停顿，但毕竟也还是要暂停的。 #### 5.8.1 Shenandoah收集器 Shenandoah是一款只有OpenJDK才会包含，而OracleJDK里反而不存在的收集器。 目标是实现一种能在任何堆内存大小下都可以把垃圾收集的停顿时间限制在十毫秒以内的垃圾收集器，该目标意味着相比CMS和G1，Shenandoah不仅要进行并发的垃圾标记，还要并发地进行对象清理后的整理动作。 #### 5.8.2 ZGC收集器 ZGC（“Z”并非什么专业名词的缩写，这款收集器的名字就叫作Z Garbage Collector）是一款在JDK 11中新加入的具有实验性质[1]的低延迟垃圾收集器，是由Oracle公司研发的。2018年Oracle创建了JEP 333将ZGC提交给OpenJDK，推动其进入OpenJDK 11的发布清单之中。 ZGC和Shenandoah的目标是高度相似的，都希望在**尽可能对吞吐量影响不太大的前提下，实现在任意堆内存大小下都可以把垃圾收集的停顿时间限制在十毫秒以内的低延迟**。 ### 5.9 如何选择垃圾收集器？ **主要因素** 1. 应用程序的主要关注点是什么？ - 如果是数据分析、科学计算类的任务，目标是能尽快算出结果，那吞吐量就是主要关注点； - 如果是SLA应用，那停顿时间直接影响服务质量，严重的甚至会导致事务超时，这样延迟就是主要关注点； - 如果是客户端应用或者嵌入式应用，那垃圾收集的内存占用则是不可忽视的。 2. 运行应用的基础设施如何？ 3. 使用JDK的发行商是什么？版本号是多少？ **如何选择？** 1. 使用**ParNew（标记复制、并行、作用于新生代） + CMS的垃圾收集器（标记清除、并行、作用于老年代）**，**追求响应速度优先**，其适用于多CPU环境的Server模式的互联网或者B/S业务。 2. 如果**追求吞吐量优先**，应用在后台运算并不需要太多交互场景的，可采用**Parallel（标记复制、并行、作用于新生代） + Parallel Old 的垃圾收集器（标记整理、并行、作用于老年代）** 3. 如果是直接面向用户提供服务的B/S系统，延迟时间是主要关注点。 - 有充足的预算但没有太多调优经验，可以选择商业性解决方案，Zing VM可以使用C4收集器 - 能够掌控软硬件型号，使用较新的版本，同时又特别注重延迟，那ZGC很值得尝试 - 遗留系统，软硬件基础设施和JDK版本都比较落后，对于大概4GB到6GB以下的堆内存，CMS一般能处理得比较好，而对于更大的堆内存，可重点考察一下G1。 4. 如果是**面向计算**，没有太多交互，注重高吞吐量，可以使用Java8默认提供的垃圾收集器——**Parallel Scavenge收集器和Parallel Old**。 ## 六、内存分配策略 ### 6.1 简述java内存分配与回收策率以及Minor GC和Major GC ``` 所谓自动内存管理，最终要解决的也就是内存分配和内存回收两个问题。前面我们介绍了内存回收，这里我们再来聊聊内存分配。 ``` ``` 对象的内存分配通常是在 Java 堆上分配（随着虚拟机优化技术的诞生，某些场景下也会在栈上分配，后面会详细介绍），对象主要分配在新生代的 Eden 区，如果启动了本地线程缓冲，将按照线程优先在 TLAB 上分配。少数情况下也会直接在老年代上分配。总的来说分配规则不是百分百固定的，其细节取决于哪一种垃圾收集器组合以及虚拟机相关参数有关，但是虚拟机对于内存的分配还是会遵循以下几种「普世」规则： ``` #### 6.1.1. 对象优先在 Eden 区分配 ``` 多数情况，对象都在新生代 Eden 区分配。当 Eden 区分配没有足够的空间进行分配时，虚拟机将会发起一次 Minor GC。如果本次 GC 后还是没有足够的空间，则将启用分配担保机制在老年代中分配内存。 ``` ``` 这里我们提到 Minor GC，如果你仔细观察过 GC 日常，通常我们还能从日志中发现 Major GC/Full GC。 ``` ``` Minor GC 是指发生在新生代的 GC，因为 Java 对象大多都是朝生夕死，所有 Minor GC 非常频繁，一般回收速度也非常快； ``` ``` Major GC/Full GC 是指发生在老年代的 GC，出现了 Major GC 通常会伴随至少一次 Minor GC。Major GC 的速度通常会比 Minor GC 慢 10 倍以上。 ``` #### 6.1.2. 大对象直接进入老年代 ``` 所谓大对象是指需要大量连续内存空间的对象，频繁出现大对象是致命的，会导致在内存还有不少空间的情况下提前触发 GC 以获取足够的连续空间来安置新对象。 ``` ``` 前面我们介绍过新生代使用的是标记-清除算法来处理垃圾回收的，如果大对象直接在新生代分配就会导致 Eden 区和两个 Survivor 区之间发生大量的内存复制。因此对于大对象都会直接在老年代进行分配。 ``` #### 6.1.3. 长期存活对象将进入老年代 ``` 虚拟机采用分代收集的思想来管理内存，那么内存回收时就必须判断哪些对象应该放在新生代，哪些对象应该放在老年代。因此虚拟机给每个对象定义了一个对象年龄的计数器，如果对象在 Eden 区出生，并且能够被 Survivor 容纳，将被移动到 Survivor 空间中，这时设置对象年龄为 1。对象在 Survivor 区中每「熬过」一次 Minor GC 年龄就加 1，当年龄达到一定程度（默认 15） 就会被晋升到老年代。 ``` **工作流程** 分代回收器有两个分区：老生代和新生代，新生代默认的空间占比总空间的 1/3，老生代的默认占比是 2/3。 新生代使用的是复制算法，新生代里有 3 个分区：Eden、To Survivor、From Survivor，它们的默认占比是 8:1:1，它的执行流程如下： - 把 Eden + From Survivor 存活的对象放入 To Survivor 区； - 清空 Eden 和 From Survivor 分区； - From Survivor 和 To Survivor 分区交换，From Survivor 变 To Survivor，To Survivor 变 From Survivor。 - 每次在 From Survivor 到 To Survivor 移动时都存活的对象，年龄就 +1，当年龄到达 15（默认配置是 15）时，升级为老生代。大对象也会直接进入老生代。 老生代当空间占用到达某个值之后就会触发全局垃圾收回，一般使用标记整理的执行算法。以上这些循环往复就构成了整个分代垃圾回收的整体执行流程。 #### 6.1.4. 动态对象年龄判定 虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。 #### 6.1.5. 空间分配担保 在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。 如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那么就要进行一次 Full GC。 ### 6.2 Full GC 的触发条件 对于 Minor GC，其触发条件非常简单，当 Eden 空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件: #### 6.2.1. 调用 System.gc() 只是建议虚拟机执行 Full GC，但是虚拟机不一定真正去执行。不建议使用这种方式，而是让虚拟机管理内存。 #### 6.2.2. 老年代空间不足 老年代空间不足的常见场景为前文所讲的大对象直接进入老年代、长期存活的对象进入老年代等。 为了避免以上原因引起的 Full GC，应当尽量不要创建过大的对象以及数组。除此之外，可以通过 -Xmn 虚拟机参数调大新生代的大小，让对象尽量在新生代被回收掉，不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄，让对象在新生代多存活一段时间。 #### 6.2.3. 空间分配担保失败 使用复制算法的 Minor GC 需要老年代的内存空间作担保，如果担保失败会执行一次 Full GC。具体内容请参考上面的第五小节。 #### 6.2.4. JDK 1.7 及以前的永久代空间不足 在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据。 当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。 为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。 #### 6.2.5. Concurrent Mode Failure 执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足(可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足)，便会报 Concurrent Mode Failure 错误，并触发 Full GC。 ## 七、虚拟机类加载机制 ### 7.1. 简述java类加载机制? 虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，解析和初始化，最终形成可以被虚拟机直接使用的java类型。 ### 7.2. 描述一下JVM加载Class文件的原理机制 Java中的所有类，都需要由类加载器装载到JVM中才能运行。类加载器本身也是一个类，而它的工作就是把class文件从硬盘读取到内存中。在写程序的时候， 我们几乎不需要关心类的加载，因为这些都是隐式装载的，除非我们有特殊的用法，像是反射，就需要显式的加载所需要的类。 类装载方式，有两种 ： 1. **隐式装载**， 程序在运行过程中当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类到jvm中， 2. **显式装载**， 通过class.forname()等方法，显式加载需要的类 Java类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类(像是基类)完全加载到jvm中，至于其他类，则在需要的时候才加载。这当然就是为了节省内存开销。 ### 7.3. 什么是类加载器，类加载器有哪些? 实现通过类的权限定名获取该类的二进制字节流的代码块叫做类加载器。 主要有一下四种类加载器: 1. **启动类加载器(Bootstrap ClassLoader)**：用来加载java核心类库，无法被java程序直接引用。 2. **扩展类加载器(extensions class loader)**：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。 3. **系统类加载器（system class loader）**：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。 4. **用户自定义类加载器**，通过继承 java.lang.ClassLoader类的方式实现。 ### 7.4. 说一下类装载的执行过程  类装载分为以下 5 个步骤： 1. **加载**：根据查找路径找到相应的 class 文件然后导入； 2. **验证**：检查加载的 class 文件的正确性； 3. **准备**：给类中的静态变量分配内存空间； 4. **解析**：虚拟机将常量池中的符号引用替换成直接引用的过程。符号引用就理解为一个标示，而在直接引用直接指向内存中的地址； 5. **初始化**：对静态变量和静态代码块执行初始化工作。 ### 7.5. 双亲委派模型 <img src="https://gitee.com/jiao_qianjin/zhishiku/raw/master/img/20211125152946.png" alt="img" style="zoom: 80%;" /> 类加载器分类： - **启动类加载器（Bootstrap ClassLoader）**，是虚拟机自身的一部分，用来加载Java_HOME/lib/目录中的，或者被 -Xbootclasspath 参数所指定的路径中并且被虚拟机识别的类库； - **其他类加载器：** - **扩展类加载器**（Extension ClassLoader）：负责加载\lib\ext目录或Java. ext. dirs系统变量指定的路径中的所有类库； - **应用程序类加载器**（Application ClassLoader）。负责加载用户类路径（classpath）上的指定类库，我们可以直接使用这个类加载器。一般情况，如果我们没有自定义类加载器默认就是用这个加载器。 #### 7.5.1 双亲委派模型： 如果一个类加载器收到了类加载的请求，它首先不会自己去加载这个类，而是把这个请求委派给父类加载器去完成，每一层的类加载器都是如此，这样所有的加载请求都会被传送到顶层的启动类加载器中，只有当父加载无法完成加载请求（它的搜索范围中没找到所需的类）时，子加载器才会尝试去加载类。 **当一个类收到了类加载请求时，不会自己先去加载这个类，而是将其委派给父类，由父类去加载，如果此时父类不能加载，反馈给子类，由子类去完成类的加载。** #### 7.5.2 好处 使用双亲委派模型来组织类加载器之间的关系，一个显而易见的好处就是Java中的类随着它的类加载器一起具备了一种带有优先级的层次关系。 双亲委派模型**保证了Java程序的稳定运行，可以避免类的重复加载**（JVM 区分不同类的方式不仅仅根据类名，相同的类文件被不同的类加载器加载产生的是两个不同的类），也保证了 Java 的核心 API 不被篡改。如果没有使用双亲委派模型，而是每个类加载器加载自己的话就会出现一些问题，比如我们编写一个称为 `java.lang.Object` 类的话，那么程序运行的时候，系统就会出现多个不同的 `Object` 类。 #### 7.5.3 如何破坏双亲委派模型？ 自定义加载器的话，需要继承 `ClassLoader` 。如果我们不想打破双亲委派模型，就重写 `ClassLoader` 类中的 `findClass()` 方法即可，无法被父类加载器加载的类最终会通过这个方法被加载。但是，如果想打破双亲委派模型则需要重写 `loadClass()` 方法 #### 7.5.4 自定义类加载器 除了 `BootstrapClassLoader` 其他类加载器均由 Java 实现且全部继承自`java.lang.ClassLoader`。如果我们要自定义自己的类加载器，很明显需要继承 `ClassLoader`。 ## 八、JVM调优 ### 1. 说一下 JVM 调优的工具？ JDK 自带了很多监控工具，都位于 JDK 的 bin 目录下，其中最常用的是 jconsole 和 jvisualvm 这两款视图监控工具。 - **jconsole：**用于对 JVM 中的内存、线程和类等进行监控； - **jvisualvm：**JDK 自带的全能分析工具，可以分析：内存快照、线程快照、程序死锁、监控内存的变化、gc 变化等。 ### 2. 常用的 JVM 调优的参数都有哪些？ - **-Xms2g**：初始化推大小为 2g； - -**Xmx2g**：堆最大内存为 2g； - -**XX:NewRatio=4**：设置年轻的和老年代的内存比例为 1:4； - **-XX:SurvivorRatio=8**：设置新生 - 代 Eden 和 Survivor 比例为 8:2； - **–XX:+UseParNewGC**：指定使用 ParNew + Serial Old 垃圾回收器组合； - **-XX:+UseParallelOldGC**：指定使用 ParNew + ParNew Old 垃圾回收器组合； - **-XX:+UseConcMarkSweepGC**：指定使用 CMS + Serial Old 垃圾回收器组合； - **-XX:+PrintGC**：开启打印 gc 信息； - **-XX:+PrintGCDetails**：打印 gc 详细信息。 ### 3. 大内存硬件上的程序部署策略 目前单体应用在较大内存硬件上的主要部署方式有两种： - 通过一个单独的Java虚拟机实例来管理大量的Java堆内存。 - 同时使用若干个Java虚拟机，建立逻辑集群来利用硬件资源（分布式，负载均衡） Last modification：November 25th, 2021 at 04:07 pm © 允许规范转载