JVM架构、内存管理、垃圾回收、调优

JVM架构和GC垃圾回收机制详解

JVM架构图分析

下图：参考网络+书籍，如有侵权请见谅 （想了解Hadoop内存溢出请看： Hadoop内存溢出(OOM)分类、参数调优化）

JVM架构、内存管理、垃圾回收、调优

JVM被分为三个主要的子系统

（1）类加载器子系统（2）运行时数据区（3）执行引擎

1. 类加载器子系统

Java的动态类加载功能是由类加载器子系统处理。当它在运行时（不是编译时）首次引用一个类时，它加载、链接并初始化该类文件。

1.1 加载

类由此组件加载。启动类加载器 (BootStrap class Loader)、扩展类加载器(Extension class Loader)和应用程序类加载器(Application class Loader) 这三种类加载器帮助完成类的加载。

1.  启动类加载器 – 负责从启动类路径中加载类，无非就是rt.jar。这个加载器会被赋予最高优先级。

2.  扩展类加载器 – 负责加载ext 目录(jre\lib)内的类.

3.  应用程序类加载器 – 负责加载应用程序级别类路径，涉及到路径的环境变量等etc.

上述的类加载器会遵循委托层次算法（Delegation Hierarchy Algorithm）加载类文件。

1.2 链接

1.  校验 – 字节码校验器会校验生成的字节码是否正确，如果校验失败，我们会得到校验错误。

2.  准备 – 分配内存并初始化默认值给所有的静态变量。

3.  解析 – 所有符号内存引用被方法区(Method Area)的原始引用所替代。

1.3 初始化

这是类加载的最后阶段，这里所有的静态变量会被赋初始值, 并且静态块将被执行。

2. 运行时数据区（Runtime Data Area）

The 运行时数据区域被划分为5个主要组件：

2.1 方法区（Method Area）

所有类级别数据将被存储在这里，包括静态变量。每个JVM只有一个方法区，它是一个共享的资源。

2.2 堆区（Heap Area）

所有的对象和它们相应的实例变量以及数组将被存储在这里。每个JVM同样只有一个堆区。由于方法区和堆区的内存由多个线程共享，所以存储的数据不是线程安全的。

2.3 栈区（Stack Area）

对每个线程会单独创建一个运行时栈。对每个函数呼叫会在栈内存生成一个栈帧(Stack Frame)。所有的局部变量将在栈内存中创建。栈区是线程安全的，因为它不是一个共享资源。栈帧被分为三个子实体：

a 局部变量数组 – 包含多少个与方法相关的局部变量并且相应的值将被存储在这里。

b 操作数栈 – 如果需要执行任何中间操作，操作数栈作为运行时工作区去执行指令。

c 帧数据 – 方法的所有符号都保存在这里。在任意异常的情况下，catch块的信息将会被保存在帧数据里面。

2.4 PC寄存器

每个线程都有一个单独的PC寄存器来保存当前执行指令的地址，一旦该指令被执行，pc寄存器会被更新至下条指令的地址。

2.5 本地方法栈

本地方法栈保存本地方法信息。对每一个线程，将创建一个单独的本地方法栈。

3. 执行引擎

分配给运行时数据区的字节码将由执行引擎执行。执行引擎读取字节码并逐段执行。

3.1  解释器:

 解释器能快速的解释字节码，但执行却很慢。 解释器的缺点就是,当一个方法被调用多次，每次都需要重新解释。

编译器

JIT编译器消除了解释器的缺点。执行引擎利用解释器转换字节码，但如果是重复的代码则使用JIT编译器将全部字节码编译成本机代码。本机代码将直接用于重复的方法调用，这提高了系统的性能。

a. 中间代码生成器 – 生成中间代码

b. 代码优化器 – 负责优化上面生成的中间代码

c. 目标代码生成器 – 负责生成机器代码或本机代码

d.  探测器(Profiler) – 一个特殊的组件，负责寻找被多次调用的方法。

3.3  垃圾回收器:

收集并删除未引用的对象。可以通过调用"System.gc()"来触发垃圾回收，但并不保证会确实进行垃圾回收。JVM的垃圾回收只收集哪些由new关键字创建的对象。所以，如果不是用new创建的对象，你可以使用finalize函数来执行清理。

Java本地接口 (JNI): JNI 会与本地方法库进行交互并提供执行引擎所需的本地库。

本地方法库:它是一个执行引擎所需的本地库的集合。

JVM三大核心区域

JVM架构、内存管理、垃圾回收、调优

通过一个小程序认识JVM

 

  1. package com.spark.jvm;

  2. /**

  3. * 从JVM调用的角度分析java程序堆内存空间的使用：

  4. * 当JVM进程启动的时候，会从类加载路径中找到包含main方法的入口类HelloJVM

  5. * 找到HelloJVM会直接读取该文件中的二进制数据，并且把该类的信息放到运行时的Method内存区域中。

  6. * 然后会定位到HelloJVM中的main方法的字节码中，并开始执行Main方法中的指令

  7. * 此时会创建Student实例对象，并且使用student来引用该对象（或者说给该对象命名），其内幕如下：

  8. * 第一步：JVM会直接到Method区域中去查找Student类的信息，此时发现没有Student类，就通过类加载器加载该Student类文件；

  9. * 第二步：在JVM的Method区域中加载并找到了Student类之后会在Heap区域中为Student实例对象分配内存，

  10. * 并且在Student的实例对象中持有指向方法区域中的Student类的引用（内存地址）；

  11. * 第三步：JVM实例化完成后会在当前线程中为Stack中的reference建立实际的应用关系，此时会赋值给student

  12. * 接下来就是调用方法

  13. * 在JVM中方法的调用一定是属于线程的行为，也就是说方法调用本身会发生在线程的方法调用栈：

  14. * 线程的方法调用栈（Method Stack Frames），每一个方法的调用就是方法调用栈中的一个Frame，

  15. * 该Frame包含了方法的参数，局部变量，临时数据等 student.sayHello();

  16. */

  17. public class HelloJVM {

  18. //在JVM运行的时候会通过反射的方式到Method区域找到入口方法main

  19. public static void main(String[] args) {//main方法也是放在Method方法区域中的

  20. /**

  21. * student(小写的)是放在主线程中的Stack区域中的

  22. * Student对象实例是放在所有线程共享的Heap区域中的

  23. */

  24. Student student = new Student("spark");

  25. /**

  26. * 首先会通过student指针（或句柄）（指针就直接指向堆中的对象，句柄表明有一个中间的,student指向句柄，句柄指向对象）

  27. * 找Student对象，当找到该对象后会通过对象内部指向方法区域中的指针来调用具体的方法去执行任务

  28. */

  29. student.sayHello();

  30. }

  31. }

  32.  

  33. class Student {

  34. // name本身作为成员是放在stack区域的但是name指向的String对象是放在Heap中

  35. private String name;

  36. public Student(String name) {

  37. this.name = name;

  38. }

  39. //sayHello这个方法是放在方法区中的

  40. public void sayHello() {

  41. System.out.println("Hello, this is " + this.name);

  42. }

  43. }

  44. 三、JVM内存管理和垃圾回收

    JVM内存组成结构

    JVM栈由堆、栈、本地方法栈、方法区等部分组成，结构图如下所示：

    JVM架构、内存管理、垃圾回收、调优

    1）堆

    所有通过new创建的对象的内存都在堆中分配，堆的大小可以通过-Xmx和-Xms来控制。堆被划分为新生代和旧生代，新生代又被进一步划分为Eden和Survivor区，最后Survivor由From Space和To Space组成，结构图如下所示：

    JVM架构、内存管理、垃圾回收、调优

  45. 新生代。新建的对象都是用新生代分配内存，Eden空间不足的时候，会把存活的对象转移到Survivor中，新生代大小可以由-Xmn来控制，也可以用-XX:SurvivorRatio来控制Eden和Survivor的比例

  46. 旧生代。用于存放新生代中经过多次垃圾回收仍然存活的对象

  47. 持久带（Permanent Space）实现方法区，主要存放所有已加载的类信息，方法信息，常量池等等。可通过-XX:PermSize和-XX:MaxPermSize来指定持久带初始化值和最大值。Permanent Space并不等同于方法区，只不过是Hotspot JVM用Permanent Space来实现方法区而已，有些虚拟机没有Permanent Space而用其他机制来实现方法区。

  48. -XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。

    -XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数。

    JVM架构、内存管理、垃圾回收、调优

    -Xmx:最大堆内存,如：-Xmx512m

    -Xms:初始时堆内存,如：-Xms256m

    -XX:MaxNewSize:最大年轻区内存

    -XX:NewSize:初始时年轻区内存.通常为 Xmx 的 1/3 或 1/4。新生代 = Eden + 2 个 Survivor 空间。实际可用空间为 = Eden + 1 个 Survivor，即 90%

    -XX:MaxPermSize:最大持久带内存

    -XX:PermSize:初始时持久带内存

    -XX:+PrintGCDetails。打印 GC 信息

     -XX:NewRatio 新生代与老年代的比例，如 –XX:NewRatio=2，则新生代占整个堆空间的1/3，老年代占2/3

     -XX:SurvivorRatio 新生代中 Eden 与 Survivor 的比值。默认值为 8。即 Eden 占新生代空间的 8/10，另外两个 Survivor 各占 1/10

     

    2）栈

        每个线程执行每个方法的时候都会在栈中申请一个栈帧，每个栈帧包括局部变量区和操作数栈，用于存放此次方法调用过程中的临时变量、参数和中间结果。

       -xss:设置每个线程的堆栈大小. JDK1.5+ 每个线程堆栈大小为 1M，一般来说如果栈不是很深的话， 1M 是绝对够用了的。

    3）本地方法栈

    用于支持native方法的执行，存储了每个native方法调用的状态

    4）方法区

    存放了要加载的类信息、静态变量、final类型的常量、属性和方法信息。JVM用持久代（Permanet Generation）来存放方法区，可通过-XX:PermSize和-XX:MaxPermSize来指定最小值和最大值

     

    垃圾回收按照基本回收策略分

    引用计数（Reference Counting）:

    比较古老的回收算法。原理是此对象有一个引用，即增加一个计数，删除一个引用则减少一个计数。垃圾回收时，只用收集计数为0的对象。此算法最致命的是无法处理循环引用的问题。

     

    标记-清除（Mark-Sweep）:

    JVM架构、内存管理、垃圾回收、调优

        此算法执行分两阶段。第一阶段从引用根节点开始标记所有被引用的对象，第二阶段遍历整个堆，把未标记的对象清除。此算法需要暂停整个应用，同时，会产生内存碎片。

     

    复制（Copying）:

    JVM架构、内存管理、垃圾回收、调优

        此算法把内存空间划为两个相等的区域，每次只使用其中一个区域。垃圾回收时，遍历当前使用区域，把正在使用中的对象复制到另外一个区域中。算法每次只处理正在使用中的对象，因此复制成本比较小，同时复制过去以后还能进行相应的内存整理，不会出现“碎片”问题。当然，此算法的缺点也是很明显的，就是需要两倍内存空间。

     

    标记-整理（Mark-Compact）:

    JVM架构、内存管理、垃圾回收、调优

     

        此算法结合了“标记-清除”和“复制”两个算法的优点。也是分两阶段，第一阶段从根节点开始标记所有被引用对象，第二阶段遍历整个堆，把清除未标记对象并且把存活对象“压缩”到堆的其中一块，按顺序排放。此算法避免了“标记-清除”的碎片问题，同时也避免了“复制”算法的空间问题。

     

    JVM分别对新生代和旧生代采用不同的垃圾回收机制

           新生代的GC：

           新生代通常存活时间较短，因此基于Copying算法来进行回收，所谓Copying算法就是扫描出存活的对象，并复制到一块新的完全未使用的空间中，对应于新生代，就是在Eden和From Space或To Space之间copy。新生代采用空闲指针的方式来控制GC触发，指针保持最后一个分配的对象在新生代区间的位置，当有新的对象要分配内存时，用于检查空间是否足够，不够就触发GC。当连续分配对象时，对象会逐渐从eden到survivor，最后到旧生代。

    在执行机制上JVM提供了串行GC（Serial GC）、并行回收GC（Parallel Scavenge）和并行GC（ParNew）

    1）串行GC

        在整个扫描和复制过程采用单线程的方式来进行，适用于单CPU、新生代空间较小及对暂停时间要求不是非常高的应用上，是client级别默认的GC方式，可以通过-XX:+UseSerialGC来强制指定

    2）并行回收GC

        在整个扫描和复制过程采用多线程的方式来进行，适用于多CPU、对暂停时间要求较短的应用上，是server级别默认采用的GC方式，可用-XX:+UseParallelGC来强制指定，用-XX:ParallelGCThreads=4来指定线程数

    3）并行GC

    与旧生代的并发GC配合使用

    旧生代的GC：

        旧生代与新生代不同，对象存活的时间比较长，比较稳定，因此采用标记（Mark）算法来进行回收，所谓标记就是扫描出存活的对象，然后再进行回收未被标记的对象，回收后对用空出的空间要么进行合并，要么标记出来便于下次进行分配，总之就是要减少内存碎片带来的效率损耗。在执行机制上JVM提供了串行GC（Serial MSC）、并行GC（parallel MSC）和并发GC（CMS），具体算法细节还有待进一步深入研究。

    以上各种GC机制是需要组合使用的，指定方式由下表所示：

    指定方式

    新生代GC方式

    旧生代GC方式

    -XX:+UseSerialGC

    串行GC

    串行GC

    -XX:+UseParallelGC

    并行回收GC

    并行GC

    -XX:+UseConeMarkSweepGC

    并行GC

    并发GC

    -XX:+UseParNewGC

    并行GC

    串行GC

    -XX:+UseParallelOldGC

    并行回收GC

    并行GC

    -XX:+ UseConeMarkSweepGC

    -XX:+UseParNewGC

    串行GC

    并发GC

    不支持的组合

    1、-XX:+UseParNewGC -XX:+UseParallelOldGC

    2、-XX:+UseParNewGC -XX:+UseSerialGC

     

    四、JVM内存调优

     

        首先需要注意的是在对JVM内存调优的时候不能只看操作系统级别Java进程所占用的内存，这个数值不能准确的反应堆内存的真实占用情况，因为GC过后这个值是不会变化的，因此内存调优的时候要更多地使用JDK提供的内存查看工具，比如JConsole和Java VisualVM。

        对JVM内存的系统级的调优主要的目的是减少GC的频率和Full GC的次数，过多的GC和Full GC是会占用很多的系统资源（主要是CPU），影响系统的吞吐量。特别要关注Full GC，因为它会对整个堆进行整理，导致Full GC一般由于以下几种情况：

    旧生代空间不足
        调优时尽量让对象在新生代GC时被回收、让对象在新生代多存活一段时间和不要创建过大的对象及数组避免直接在旧生代创建对象 

    Pemanet Generation空间不足
        增大Perm Gen空间，避免太多静态对象 

        统计得到的GC后晋升到旧生代的平均大小大于旧生代剩余空间
        控制好新生代和旧生代的比例 

    System.gc()被显示调用
        垃圾回收不要手动触发，尽量依靠JVM自身的机制 

        调优手段主要是通过控制堆内存的各个部分的比例和GC策略来实现，下面来看看各部分比例不良设置会导致什么后果

    1）新生代设置过小

        一是新生代GC次数非常频繁，增大系统消耗；二是导致大对象直接进入旧生代，占据了旧生代剩余空间，诱发Full GC

    2）新生代设置过大

        一是新生代设置过大会导致旧生代过小（堆总量一定），从而诱发Full GC；二是新生代GC耗时大幅度增加

        一般说来新生代占整个堆1/3比较合适

    3）Survivor设置过小

        导致对象从eden直接到达旧生代，降低了在新生代的存活时间

    4）Survivor设置过大

        导致eden过小，增加了GC频率

        另外，通过-XX:MaxTenuringThreshold=n来控制新生代存活时间，尽量让对象在新生代被回收

        由内存管理和垃圾回收可知新生代和旧生代都有多种GC策略和组合搭配，选择这些策略对于我们这些开发人员是个难题，JVM提供两种较为简单的GC策略的设置方式

    1）吞吐量优先

        JVM以吞吐量为指标，自行选择相应的GC策略及控制新生代与旧生代的大小比例，来达到吞吐量指标。这个值可由-XX:GCTimeRatio=n来设置

    2）暂停时间优先

        JVM以暂停时间为指标，自行选择相应的GC策略及控制新生代与旧生代的大小比例，尽量保证每次GC造成的应用停止时间都在指定的数值范围内完成。这个值可由-XX:MaxGCPauseRatio=n来设置

     

    最后汇总一下JVM常见配置

    堆设置

    -Xms:初始堆大小

    -Xmx:最大堆大小

    -XX:NewSize=n:设置年轻代大小

    -XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4

    -XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5

    -XX:MaxPermSize=n:设置持久代大小

    收集器设置

    -XX:+UseSerialGC:设置串行收集器

    -XX:+UseParallelGC:设置并行收集器

    -XX:+UseParalledlOldGC:设置并行年老代收集器

    -XX:+UseConcMarkSweepGC:设置并发收集器

    垃圾回收统计信息

    -XX:+PrintGC

    -XX:+PrintGCDetails

    -XX:+PrintGCTimeStamps

    -Xloggc:filename

    并行收集器设置

    -XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。

    -XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间

    -XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)

    并发收集器设置

相关文章：

  • 2021-05-25
  • 2021-12-13
  • 2022-02-12
  • 2021-11-08
  • 2021-12-28
  • 2022-01-23
  • 2021-06-14
猜你喜欢
  • 2021-08-05
  • 2021-12-13
  • 2021-11-13
  • 2021-10-08
  • 2021-05-15
  • 2021-12-21
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode