IT评测·应用市场-qidao123.com

标题: 【面试】JVM [打印本页]

---

作者: 李优秀    时间: 2025-3-13 23:19
标题: 【面试】JVM
1、JVM 内存布局

根据Java虚拟机规范的界说，JVM的运行时内存区域注要由堆、虚拟机栈、本地方法栈、方法区和程序计数器以及运行时常量池组成。此中堆、方法区以及运行时常量池是线程之间共享的区域，而栈（本地方法栈+虚拟机栈)、程序计数器都是线程独享的。
演变过程

JVM 程序计数器
用于记录虚以机正在执行的字节码指令的地址。它是线程私有的，为每个线程维护一个独立的程序计数器，用于指示下一条将要被执行的字节码指令的位置。它包管线程执行一个字节码指令以后，才会去执行下一个字节码指令。
在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时间能够知道该线程前次运行到哪儿了。在线程中程序计数器私有重要是为了线程切换后能规复到精确的执行位置。以是程序计数器一定是线程私有的。
JVM 虚拟机栈

JVM中的方法栈是线程私有的，每一个方法的调用会在方法栈中加入一个栈帧，比如这样启动 main 方法

1. public static void main(String[] args) {
2.     methodA();
3. }
5. public static void methodA() {
6.         int a = 0;
7.         int b = a + 3;
8.         methodB();
9. }
11. public static void methodB() {
13. }

复制代码

栈中压入 main 方法的栈帧，执行到 methodA 方法，栈中压入 methodA 方法的栈帧，执行到 methodB 方法，栈中压入 methodB 方法的栈帧，每个方法执行完成之后，这个方法所对应的栈帧就会出栈，每个栈帧中大概存储这五个内容：局部变量表（存储局部变量的空间）、操纵数栈（线程执行时使用到的数据存储空间）、动态链接（方法区的引用，例如类信息，常量、静态变量）、返回地址（存储这个方法被调用的位置，由于方法执行后还需要到方法被调用的位置）、附加信息（增长的一些规范里面没有的信息，可以添加自己的附加信息），这就是栈和栈帧。
本地方法栈
和虚拟机栈所发挥的作用非常相似，区别是： 虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
堆
堆是存储对象实例的运行时内存区域。它是虚拟机运行时的内存总体的最大的一块，也一直占据着虚拟机内存总量的一大部分。Java堆由Java虚拟机管理，用于存放对象实例，几乎全部的对象实例都要在上面分配内存。别的，Java堆还用于垃圾接纳，虚拟机发现没有被引用的对象时，就会对堆中对象进行垃圾接纳，以开释内存空间。
现代垃圾收集器大部分都基于分代收集理论设计，堆空间细分为：
Java 7及之前堆内存逻辑上分为三部分：新生代+老年代+永世代，Java 8及之后堆内存逻辑上分为三部分：新生代+老年代+元空间

设置堆巨细与OOM
Java堆区用于存储Java对象实例，那么堆的巨细在JVM启动时就已经设定好了，可以通过选项"-Xmx"和"-Xms"来进行设置

• "-Xms"用于表示堆区的起始内存，等价于-XX: InitialHeapsize。
  
• "-Xmx"则用于表示堆区的最大内存，等价于-XX:MaxHeapsize。
  

一旦堆区中的内存巨细凌驾"-Xmx"所指定的最大内存时,将会抛出OutOfMemoryError异常。
通常会将-Xms和-Xmx两个参数设置相同的值，其目标是为了能够在java垃圾接纳机制清理完堆区后不需要重新分隔盘算堆区的巨细，从而进步性能。
默认情况下，初始内存巨细：物理电脑内存巨细/ 64 最大内存巨细:物理电脑内存巨细/4。
注意：设置的堆巨细不包含元空间(或永世代)
TLAB
先来看对象的创建过程，为对象分配空间的任务等同于在java堆中划分一块巨细确定的内存出来，假设java堆空间内存是绝对规整的，全部使用过的内存都放在一边，没有使用过的内存放在另一半，中心放着一个指针作为分界点的指示器，当分配内存就仅仅是把指针想空闲的空间移动一段与对象巨细相当的距离，这种分配方法称为指针碰撞(Bump The Pointer)。
对象创建在虚拟机中黑白常频繁的活动，纵然仅仅修改一个指针所指向的位置，在并发情况下也并不是线程安全的，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又使用了原来的指针来分配内存的情况。
解决方案其一就是使用本地线程分配缓冲(TLAB)，对Eden区继续进行划分，JVM为每个线程分配了一个私有缓存区域，它包含在Eden区内，即每个线程在java堆中预先分配一小块内存，哪个线程需要分配内存，就在哪个线程的本地缓冲区中分配，当本地缓冲使用完，分配新的缓存区时才需要同步锁定。

尽管不是全部对象实例都能在TLAB中成功分配内存，但是JVM确定是将TLAB作为内存分配的首选，可以通过选项 -XX:UseTLAB 设置是否开启TLAB空间，默认的情况下TLAB占用的内存非常小，仅占用Eden空间的1%。
堆的内存分配过程

• 最开始应该使用线程分配缓冲区(tlab)来给对象分配空间，每个线程都有一个tlab，它可以包管线程的安全。
  
• 使用tlab分配空间失败时考虑通过加锁的方式(多线程)，在eden区分配空间，如果eden区满了，就会触发一次minor gc，它会清撤除没有用的对象，判断一个对象是否能被搜集通常有两种算法：引用计数器法、可达性分析法；存活下来的对象将会进入eden的from区，然后清空eden区。
  
• 当eden区满了，会第二次触发minor gc，他会将eden存活下来的对象放入to区，from存活下来的对象年龄+1后也进入to区，然后清空eden区和from区。
  
• 当eden区再次满时，第三次执行minor gc，这一次eden区存活下来的对象进入from区，to区存活下来的对象年龄+1也会进入from区，然后清空eden区和to区。
  
• 随着对象的数目增长，不停的做上面两次操纵，到对象的年龄到达老年带所规定的年龄阈值的时间，对象从新生代进入老年代。
  
• 随着对象增长，老年代满时会执行major gc操纵，gc后对象仍然无法生存报内存溢出。
  

方法区
用于存诸已被加载的类信息、常量、静态变量、即时编译后的代码等数据的内存区域。每加载一个类，方法区就会分配一定的内存空间，用于存储该类的相干信息，这部分空间随着需要而动态变革。方法区的详细实现形式可以有多种，比如堆、永世代、元空间等。

运行时常量池
是方法区的一部分。用于存储编译阶段生成的信息，重要有字面量和符号引用常量两类。此中字面量包括了文本字符串、被声明final的常量值、根本数据范例的值和其他。此中符号引用常量包括了类的全限定名称、字段的名称和描述符、方法的名称和描述符。
堆和栈的区别

• 存储位置差别，堆是在堆内存中分配空间，而栈是在的栈内存中分配空间。
  
• 存储的内容差别，堆中重要存储对象，栈中重要存储本地变量。
  
• 堆是线程共享的，栈是线程独享的。
  
• 堆是垃圾接纳的重要区域，不再引用这个对象，会被垃圾接纳机制会自动接纳。栈的内存使用是一种先进后出的机制，栈中的变量会在程序执行完毕后自动开释。
  
• 栈的巨细比堆要小的多，一样平常是几百到几干字节。
  
• 栈的存储速率比堆快，代码执行效率高。
  
• 堆上会发生OutofMemoryError，栈上会发生StackOverflowError。
  

2、Java 的堆是如何分代的

Java的堆内存分代是指将差别生命周期的堆内存对象存储在差别的堆内存区域中，这里的差别的堆内存区域被界说为"代”。这样做有助于提升垃圾接纳的效率，由于这样的话就可以为差别的"代"设置差别的接纳策略。
一样平常来说，Java中的大部分对象都是朝生夕死的，同时也有一部分对象会长期存在。由于如果把这两部分对象放
到一起分析和接纳，这样效率实在是太低了。通过将差别时期的对象存储在差别的内存池中，就可以节省名贵的时
间和空间，从而改善体系的性能。
Java的堆由新生代(Young Generation)和老年代(Old Generation)组成。新生代存放新分配的对象，老年代存放长期存在的对象。新生代(Young)由年轻区(Eden)、Survivor区组成(From Survivor、To Survivor)。默认情况下，新生代的Eden区和Survivorl区的空间巨细比例是8：2，可以通过-X:SurvivorRatio参数调整。

对象的分代晋升
一样平常情况下，对象将在新生代进行分配，起首会实验在Eden区分配对象，当Eden内存耗尽，无法满意新的对象分
配请求时，将触发新生代的GC(Young GC、MinorGC)，在新生代的GC过程中，没有被接纳的对象会从Eden区被
般运到Survivo区，这个过程通常被称为"晋升"。
同样的，对象也可能会晋升到老年代，触发条件重要看对象的巨细和年龄。对象进入老年代的条件有三个，满意一
个就会进入到老年代：

• 躲过15次GC。每次垃圾接纳后，存活的对象的年龄就会加1，累计加到15次(Gdk8默认的)，也就是某个对象躲过了1次垃圾接纳，那么J小M就认为这个是经常被使用的对象，就没须要再待在年轻代中了。详细的次数可以通过-XX:MaxTenuringThreshold来设置在躲过多少次垃圾收集后进去老年代。
  
• 动态对象年龄判断。规则：在某个Survivor中，如果有一批对象的巨细总是大于该Survivor的50%，那么此时大于等于该批对象年龄的对象就会直接到老年代中。
  
• 大对象直接进入老年代。-XXretenureSizeThreshold来设置大对象的l临界值，大于该值的就被认为是大对象，就会直接进入老年代。
  

什么是永世代
永世代(Permanent Generation)是HotSpot)虚拟机在从前版本中使用的一个永世内存区域，是VM中垃圾收集堆之外的另一个内存区域，它重要用来实现方法区的，此中存储了Class类信息、常量池以及静态变量等数据。
Java8以后，永世代被重构为元空间(MetaSpace)。但是，和新生代、老年代一样，永世代也是可能会发生GC的。而且，永世代也是有可能导致内存益出。只要永世代的内存分配凌驾限定指定的最大值，就会出现内存溢出。
3、如果 YoungGC 存活的对象所需要的空间比 Survivor 区域的空间大怎么办

毕竟一块Survivor区域的比例只是年轻的10%而已。这时间就需要把对象移动到老年代。
空间分配包管机制
如果Survivor区域的空间不够，就要分配给老年代，也就是说，老年代起到了一个兜底的作用。但是，老年代也是
可能空间不足的。以是，在这个过程中就需要做一次空间分配包管(CMS)：

• 剩余的存活对象巨细，小于Survivorl区，那就直接进入Survivor区。
  
• 剩余的存活对象巨细，大于Survivor区，小于老年代可用内存，那就直接去老年代。
  
• 剩余的存活对象巨细，大于Survivor+老年代，触发"FullGC"。
  

4、YoungGC 和 FullGC 的触发条件是什么

YoungGC的触发条件比较简单，那就是当年轻代中的eden区分配满的时间就会触发。
FullGC的触发条件比较复杂也比较多，重要以下几种：

• 老年代空间不足
  
  
  
  • 创建一个大对象，凌驾指定阈值会直接生存在老年代当中，如果老年代空间也不足，会触发FullGC。
    
  • YoungGC之后，发现要移到老年代的对象，老年代存不下的时间，会触发一次FullGC。
    
  
  
• 空间分配包管失败（空间分配包管)
  
• 永世代空间不足
  
  
  
  • 如果有永世代的话，当在永世代分配空间时没有富足空间的似乎还，会触发FullGC。
    
  
  
• 代码中执行System.gc
  
  
  
  • 代码中执行System.gc的时间，会触发FullGC，但是并不包管一定会立刻触发。
    
  
  

5、什么是 Stop The World

Java中Stop-The-Vorld机制简称STW，是在执行垃圾收集算法时，Java应用程序的其他全部线程都被挂起。这是
Java中一种全局停息现象，全局停顿，全部java代码制止，native代码可以执行，但不能与JVM交互。
不管选择哪种GC算法，stop-the-world都是不能彻底避免的，只能只管低落STW的时长。
为什么需要STW呢
起首，如果不停息用户线程，就意味着期间会不停有垃圾产生，永远也清理不干净。其次，用户线程的运行必然会导致对象的引用关系发生改变，这就会导致两种情况：漏标和错标。

• 多标：原本不是垃圾，但是GC的过程中，用户线程将其引用关系修改，导致GC Roots不可达，成为了垃圾。这种情况还好一点，无非就是产生了一些浮动垃圾，下次GC再清理就好了。
  
• 漏标：原本是垃圾，但是GC的过程中，用户线程将引用重新指向了它，这时如果GC一旦将其接纳，将会导致程序运行错误。
  

6、JVM 如何判断对象是否存活

JVM有两种算法来判断对象是否存活，分别是引用计数法和可达性分析算法

• 引用计数法：给对象中添加一个引用计数器，每当有一个地方引用它，计数器就加1；当引用失效，计数器就减1；任何时间计数器为0的对象就是不可能再被使用的。这个方法实现简单，效率高，但是现在主流的虚拟机中并没有选择这个算法来管理内存，其最重要的原因是它很难明决对象之间相互循环引用的问题。
  
• 可达性分析算法：这个算法的根本思想就是通过一系列的称为“GC Roots”的对象作为起点，从这些节点开始向下搜刮，节点所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连的话，则证明此对象是不可用的。
  

但是，并不是说当进行完可达性分析算法后，即可证明某对象可以被GC。对象是否存活，需要两次标志：

• 第一次标志通过可达性分析算法。如果没有GC Roots相毗连的引用链，那么将第一次标志。
  
• 如果对象的finalize()方法被覆盖而且没有执行过，则放在F-Queuel队列中等待执行不一定会执行，如果一段时间后该队列的finalize()方法被执行且和GC Roots关联，则移出“即将接纳”集合。如果仍然没有关联，则进行第二次标志，才会对该对象进行接纳不外现在都不提倡覆盖finalize方法，它的本意是像Cpp一样在对象销毁前执行，但是它影响了JAVA的安全和GC的性能，以是第二种判断会越来越少。
  

7、JVM 有哪些垃圾接纳算法

① 标志 - 清除算法（Tracing Collector）
标志-清除 算法是最底子的收集算法，它是由 标志 和 清除 两个步调组成的。第一步是标志存活的对象，第二步是清除没有被标志的垃圾对象。

该算法的优点是当存活对象比较多的时间，性能比较高，由于该算法只需要处理待接纳的对象，而不需要处理存活的对象。但是缺点也很显着，清除之后会产生大量不一连的内存碎片。导致之后程序在运行时需要分配较大的对象时，无法找到富足的一连内存。
② 标志 - 整理算法（Compacting Collector）
上述的 标志-清除 算法会产生内存区域使用的间断，以是为了将内存区域尽可能地一连使用， 标志-整理 算法应运而生。标志-整理 算法也是由两步组成，标志 和 整理。
和标志清除算法一样，先进行对象的标志，通过GC Roots节点扫描存活对象进行标志，将全部存活对象往一端空闲空间移动，按照内存地址依次排序，并更新对应引用的指针，然后清理末了内存地址以外的全部内存空间。

但是同样，标志整理算法也有它的缺点，一方面它要标志全部存活对象，另一方面还添加了对象的移动操纵以及更新引用地址的操纵，因此标志整理算法具有更高的使用本钱。
③ 复制算法（Copying Collector）
无论是标志-清除算法照旧垃圾-整理算法，都会涉及句柄的开销或是面对碎片化的内存接纳，以是，复制算法 出现了。
复制算法将内存区域均分为了两块（记为S0和S1），而每次在创建对象的时间，只使用此中的一块区域（例如S0），当S0使用完之后，便将S0上面存活的对象全部复制到S1上面去，然后将S0全部清理掉。复制算法重要被应用于新生代，它将内存分为巨细相同的两块，每次只使用此中的一块。在恣意时间点，全部动态分配的对象都只能分配在此中一个内存空间，而另外一个内存空间则是空闲的。

但是缺点也是很显着的，可用的内存减小了一半，存在内存浪费的情况。以是 复制算法 一样平常会用于对象存活时间比较短的区域，例如 年轻代，而存活时间比较长的 老年代 是不适合的，由于老年代存在大量存活时间长的对象，采用复制算法的时间会要求复制的对象较多，效率也就急剧降落，以是老年代一样平常会使用上文提到的 标志-整理算法。
单纯的从时间黑白上面来看：标志-清除 < 标志-复制 < 标志-整理。单纯从结果来看：标志-整理 > 标志-复制 >= 标志-清除
8、什么是三色标志算法

三色标志算法是一种垃圾接纳的标志算法，它可以让JVM不发生或仅短时间发生STW（Stop The World），从而达到清除JVM内存垃圾的目标。 JVM中的CMS、G1垃圾接纳器所使用垃圾接纳算法即为三色标志法。
三色标志法将对象分为三种状态：白色、灰色和黑色。

• 白色：该对象没有被标志过。
  
• 灰色：该对象已经被标志过了，但该对象的引用对象还没标志完。
  
• 黑色：该对象已经被标志过了，而且他的全部引用对象也都标志完了。
  
  
  
  

三色标志法的标志过程可以分为三个阶段：初始标志(Initial Marking)、并发标志(Concurrent Marking)和
重新标志(Remark)。

• 初始标志：遍历全部的根对象，将根对象和直接引用的对象标志为灰色。在这个阶段中，垃圾接纳器只会扫描
  被直接大概间接引用的对象，而不会扫描整个堆。因此，初始标志阶段的时间比较短。(Stop The World)
  
• 并发标志：在这个过程中，垃圾接纳器会从灰色对象开始遍历整个对象图，将被引用的对象标志为灰色，并将
  已经遍历过的对象标志为黑色。并发标志过程中，应用程序线程可能会修改对象图，因此垃圾接纳器需要使用 写屏蔽(Vrite Barrier)技术来包管并发标志的精确性。（不需要STW)
  
• 重新标志：重新标志的重要作用是标志在并发标志阶段中被修改的对象以及未被遍历到的对象。这个过程中，
  垃圾接纳器会从灰色对象重新开始遍历对象图，将被引用的对象标志为灰色，并将已经遍历过的对象标志为黑 色。(Stop The World)
  

在重新标志阶段结束之后，垃圾接纳器会执行清除操纵，将未被标志为可达对象的对象进行接纳，从而开释内存空
间。这个过程中，垃圾接纳器会将全部未被标志的对象标志为白色(White)。
以上三个标志阶段中，初始标志和重新标志是需要STW的，而并发标志是不需要STW的。此中最耗时的实在就是
并发标志的这个阶段，由于这个阶段需要遍历整个对象树，而三色标志把这个阶段做到了和应用线程并发执行，大
大低落了GC的停顿时长。
9、新生代和老年代的垃圾接纳器有何区别

常见的垃圾接纳器如下：

• 串行垃圾接纳器(Serial Garbage Collector)如：Serial GC，Serial Old
  
• 并行垃圾接纳器(Parallel Garbage Collector)如：Parallel Scavenge，Parallel Old，ParNew
  
• 并发标志扫描垃圾接纳器(CMS Garbage Collector)
  
• G1垃圾接纳器(G1 Garbage Collector，JDK7中推出，JDK9中设置为默认)
  
• ZGC垃圾接纳器(The Z Garbage Collector，JDK11推出)
  

垃圾收集器分类作用位置使用算法特点实用场景Serial串行新生代复制算法相应速率优先实用于单CPU情况下的client模式ParNew并行新生代复制算法相应速率优先多CPU情况Server模式下与CMS共同使用Parallel并行新生代复制算法吞吐量优先实用于背景运算而不需要太多交互的场景Serial Old串行老年代标志-整理(压缩)算法相应速率优先实用于单CPU情况下的Client模式Paraller Old并行老年代标志-整理(压缩)算法吞吐量优先实用于背景运算而不需要太多交互的场景CMS并发老年代标志-清除算法相应速率优先实用于互联网或B／S业务G1并发、并行新生代、老年代标志-整理(压缩)算法相应速率优先相应速率优先 新生代收集器有Serial、ParNew、Parallel Scavenge。
老年代收集器有Serial Old、Parallel Old、CMS。
整堆收集器有G1、ZGC。

jdk1.8默认使用ParallelGC。新生代采用的是Parallel Scavenge，老年代Parallel Old。
10、Java 中的四种引用有什么区别

• 强引用（Strong Reference）：指向对象的引用称为强引用。如果一个对象具有强引用，那么垃圾接纳器就不会接纳这个对象，纵然体系内存不足也不会接纳它。例如，以下代码中的 obj 变量就是一个强引用。
  

1. java
2. Object obj = new Object();

复制代码

• 软引用（Soft Reference）：如果一个对象只被软引用所引用，则当体系内存不足时，垃圾接纳器可能会接纳这个对象。软引用通常用来实现缓存等功能。例如，以下代码中的 softRef 变量就是一个软引用。
  

1. SoftReference<Object> softRef = new SoftReference<>(new Object());
2. Object obj = softRef.get(); // 可以通过 get() 方法获取到被引用的对象

复制代码

• 弱引用（Weak Reference）：与软引用类似，如果一个对象只被弱引用所引用，则当垃圾接纳器运行时，无论当前内存是否富足，都会接纳这个对象。弱引用通常用来避免内存走漏等问题。例如，以下代码中的 weakRef 变量就是一个弱引用。
  

1. WeakReference<Object> weakRef = new WeakReference<>(new Object());
2. Object obj = weakRef.get(); // 可以通过 get() 方法获取到被引用的对象

复制代码

• 虚引用（Phantom Reference）：如果一个对象只被虚引用所引用，则无论该对象是否有其他引用，垃圾接纳器都会将其接纳，而且在接纳前会通过队列关照一次程序。虚引用通常用来跟踪对象被垃圾收集器接纳的状态，大概在对象被接纳时执行某些操纵。例如，以下代码中的 phantomRef 变量就是一个虚引用。
  

1. ReferenceQueue<Object> queue = new ReferenceQueue<>();
2. PhantomReference<Object> phantomRef = new PhantomReference<>(new Object(), queue);
3. Object obj = phantomRef.get(); // 返回值始终为 null
4. Reference<?> ref = queue.remove(); // 可以从队列中获取到被回收的虚引用

复制代码

需要注意的是，软引用、弱引用和虚引用都继承自 Reference 类，而且它们在垃圾接纳器运行时都可能会被接纳。因此，在使用这些引用时，需要特别警惕，避免由于引用被接纳而导致程序出错。
11、Java 中类加载的过程是怎么样的

类加载重要分为三个阶段，加载，链接，初始化

• 加载
  

将类的字节码文件加载到内存中，并创建一个对应的 Class 对象来表示该类。

• 链接
  

又分为三个子阶段，验证，准备和解析

• 验证阶段重要验证加载的class是否精确，例如，验证字节码文件的格式、方法调用是否精确。
  
• 准备阶段为类的静态变量分配内存，并设置默认值。例如，如果一个类有一个静态变量 int i，则在准备阶段会为 i 分配内存，并将其初始化为 0。
  
• 解析阶段会将符号引用解析为直接引用，在一个字节码文件中会用到其他类，但是字节码文件只会存用到类的类名，解析阶段就是会根据类名找到该类加载后在方法区的地址，也就是直接引用，并更换符号引用，这样运行到字节码时，就能直接找到某个类了。
  

• 初始化
  

在链接阶段之后，就可以开始初始化了。在初始化阶段，通常情况下，初始化代码包括静态变量的赋值、静态代码块的执行等。如果一个类有父类，则需要先初始化父类，然后再初始化子类。
Java中的类什么时间会被加载

• 当创建类的实例时，如果该类还没有被加载，则会触发类的加载。例如，通过关键字new创建一个类的对象
  时，JVM会检查该类是否已经加载，如果没有加载，则会调用类加载器进行加载。
  
• 当使用类的静态变量或静态方法时，如果该类还没有被加载，则会触发类的加载。例如，当调用某个类的静态方法时，JVM会检查该类是否已经加载，如果没有加载，则会调用类加载器进行加载。
  
• 当使用反射机制问类时，如果该类还没有被加载，则会触发类的加载。例如，当使用Class.forName方法加载某个类时，M会检查该类是否已经加载，如果没有加载，则会调用类加载器进行加载。
  
• 当JVM启动时，会自动加载一些底子类，例如java.lang.Object类和java.lang.Class类等。
  

总之，Java中的类加载实在是延长加载的，除了一些底子的类以外，其他的类都是在需要使用类时才会进行加载。同时，Java还支持动态加载类，即在运行时通过程序来加载类，这为ava程序带来了更大的灵活性。
12、JVM 中一次完备的 GC 流程是怎样的

• GC 通常在以下情况下触发：
  
  
  
  • 年轻代空间不足：当 Eden 区满时，触发 Young GC。
    
  • 老年代空间不足：当老年代空间不足时，触发 Full GC。
    
  • 体系调用：通过 System.gc() 显式触发 GC（不保举）。
    
  • 元空间不足：当元空间（Metaspace）不足时，触发 Full GC。
    
  
  
• GC 的分类
  
  
  
  • Young GC（Minor GC）：只接纳年轻代（Young Generation）的内存。
    
  • Full GC（Major GC）：接纳整个堆内存（包括年轻代和老年代）以及元空间。
    
  
  

一次完备的 GC 流程（以 G1 为例）
（1）Young GC（Minor GC）Young GC 重要接纳年轻代的内存，分为以下几个阶段：

• 初始标志（Initial Mark）
  

标志 GC Roots 直接引用的对象。需要停息全部应用线程（Stop-The-World，STW）。

• 并发标志（Concurrent Mark）
  

从 GC Roots 开始，遍历对象图，标志全部存活对象。与应用线程并发执行，不需要停息应用线程。

• 最终标志（Remark）
  

处理并发标志阶段遗漏的对象。需要停息全部应用线程（STW）。

• 清理（Cleanup）
  

统计存活对象，开释完全空闲的区域。需要停息全部应用线程（STW）。

• 复制（Copying）
  

将存活对象从 Eden 区和 Survivor 区复制到另一个 Survivor 区。如果对象年龄达到阈值（默认 15），则晋升到老年代。
（2）Full GC（Major GC）Full GC 接纳整个堆内存和元空间，通常发生在以下情况：

• 老年代空间不足。
  
• 元空间不足。
  
• 显式调用 System.gc()。
  

Full GC 的流程如下：

• 初始标志（Initial Mark）
  

标志 GC Roots 直接引用的对象。需要停息全部应用线程（STW）。

• 并发标志（Concurrent Mark）
  

从 GC Roots 开始，遍历对象图，标志全部存活对象。与应用线程并发执行。

• 最终标志（Remark）
  

处理并发标志阶段遗漏的对象。需要停息全部应用线程（STW）。

• 清理（Cleanup）
  

统计存活对象，开释完全空闲的区域。需要停息全部应用线程（STW）。

• 压缩（Compaction）
  

将存活对象移动到堆的一端，开释一连的内存空间。需要停息全部应用线程（STW）。
13、如何排查 OOM 的问题

OOM（OutOfMemoryError） 是 Java 程序中常见的错误之一，表示 JVM 的内存资源已经耗尽，无法再分配新的内存。OOM 可能会导致程序崩溃，因此理解 OOM 的原因和排查方法非常重要。
OOM 的常见原因

• 内存走漏：对象不再使用，但仍被引用，无法被垃圾接纳。
  
• 内存设置不足：堆、栈、元空间等内存区域设置过小。
  
• 程序逻辑问题：创建了大量对象或线程，超出内存容量。
  
• 外部资源未开释：如文件、数据库毗连等未关闭。
  

排查 OOM 问题的步调

• 确认 OOM 范例，查看错误日志，确认 OOM 的详细范例（如 Java Heap Space、Metaspace 等）
  
• 分析堆内存，使用工具（如 jmap、jvisualvm、MAT）生成堆内存快照（Heap Dump），分析堆内存快照，找出内存占用最多的对象。检查是否存在内存走漏。
  

1. 生成堆内存快照：
2. jmap -dump:format=b,file=heapdump.hprof <pid>

复制代码

1. 查看堆内存摘要：
2. jmap -heap <pid>

复制代码

• 分析线程，使用 jstack 工具生成线程快照。检查线程数目是否过多，是否存在死锁或线程阻塞。
  

1. 生成线程快照：
2. jstack <pid> > threaddump.txt

复制代码

• 检查元空间的使用情况，确认是否加载了过多的类。调整元空间的巨细（如 -XX:MetaspaceSize、-XX:MaxMetaspaceSize）。
  
• 检查代码中是否存在内存走漏（如未关闭的资源、静态集合类等），检查是否创建了过多的对象或线程。
  
• 调整 JVM 参数，据 OOM 范例，调整 JVM 参数：
  
  
  
  • 堆内存：-Xms、-Xmx
    
  • 元空间：-XX:MetaspaceSize、-XX:MaxMetaspaceSize
    
  • 栈内存：-Xss
    
  • 直接内存：-XX:MaxDirectMemorySize
    
  
  

14、如何进行 JVM 调优

JVM 调优 是通过调整 JVM 参数、优化代码和使用符合的垃圾接纳器，以提升 Java 应用程序的性能和稳定性的过程。JVM 调优的焦点目标是减少 GC（垃圾接纳） 的开销、低落 内存占用、进步 吞吐量 和 相应速率。以下是 JVM 调优的详细步调和常用方法：
JVM 调优的目标

• 减少 GC 停顿时间：低落 Full GC 的频率和连续时间。
  
• 进步吞吐量：增长应用程序的处理本事。
  
• 低落内存占用：减少堆内存的使用，避免内存走漏。
  
• 进步相应速率：减少应用程序的延长。
  

JVM 调优的常用工具
（1）监控工具

• jstat：查看 JVM 的 GC 和内存使用情况。
  

1. jstat -gc <pid> 1000 10

复制代码

• jmap：生成堆内存快照。
  

1. jmap -dump:format=b,file=heapdump.hprof <pid>

复制代码

• jstack：生成线程快照。
  

1. jstack <pid> > threaddump.txt

复制代码

（2）分析工具

• VisualVM：图形化工具，支持实时监控和分析堆内存、线程、CPU 使用情况。
  
• MAT（Memory Analyzer Tool）：分析堆内存快照，找出内存走漏。
  
• JProfiler：贸易工具，支持深度性能分析。
  

（3）GC 日志分析工具

• GCViewer：分析 GC 日志，生成可视化报告。
  
• GCEasy：在线工具，上传 GC 日志后生成分析报告。
  
• 
  

JVM 调优的步调

• 分析应用程序
  

• 相识应用程序的范例：
  
  
  
  • CPU 麋集型：如盘算麋集型任务。
    
  • I/O 麋集型：如网络请求、文件读写。
    
  • 内存麋集型：如缓存、大数据处理。
    
  
  
• 确定性能瓶颈：
  

使用性能分析工具（如 JProfiler、VisualVM）找出 CPU、内存、I/O 等方面的瓶颈。

• 监控 JVM 状态
  

• 使用工具监控 JVM 的运行状态：
  
  
  
  • GC 日志：通过 -Xloggc 参数记录 GC 日志，分析 GC 的频率和耗时。
    
  • 堆内存使用情况：使用 jmap、jstat 等工具查看堆内存的使用情况。
    
  • 线程状态：使用 jstack 查看线程的状态，检查是否存在死锁或线程阻塞。
    
  
  

• 调整 JVM 参数
  

• 根据应用程序的需求，调整 JVM 参数，重要包括以下几类：
  
  
  
  • 初始堆巨细：-Xms
    
  • 最大堆巨细：-Xmx
    
  • 年轻代巨细：-Xmn
    
  • 老年代与年轻代的比例：-XX:NewRatio
    
  • Eden 区与 Survivor 区的比例：-XX:SurvivorRatio
    
  
  
• 垃圾接纳器选择
  
  
  
  • Serial GC：单线程 GC，适合小型应用。
    
  • Parallel GC：多线程 GC，适合高吞吐量应用。
    
  • CMS GC：低延长 GC，适合相应速率要求高的应用。
    
  • G1 GC：实用于大内存、低延长的应用。
    
  • ZGC：实用于超大内存、极低延长的应用（JDK 11+）。
    
  
  
• GC 日志和监控
  
  
  
  • 启用 GC 日志：
    
  • 启用堆内存转储：
    
  
  

1. -Xloggc:/path/to/gc.log
2. -XX:+PrintGCDetails
3. -XX:+PrintGCDateStamps

复制代码

1. -XX:+HeapDumpOnOutOfMemoryError
2. -XX:HeapDumpPath=/path/to/heapdump.hprof

复制代码

• 元空间设置
  
  
  
  • 初始元空间巨细：-XX:MetaspaceSize
    
  • 最大元空间巨细：-XX:MaxMetaspaceSize
    
  
  
• 栈内存设置
  
  
  
  • 每个线程的栈巨细：-Xss
    
  
  
• 直接内存设置
  
  
  
  • 最大直接内存巨细：-XX:MaxDirectMemorySize
    
  
  

• 优化代码
  

• 减少对象创建：避免不须要的对象创建，使用对象池等技术。
  
• 实时开释资源：关闭文件、数据库毗连等资源。
  
• 避免内存走漏：检查静态集合类、缓存等是否未开释。
  
• 优化数据布局：选择符合的数据布局（如 ArrayList vs LinkedList）。
  

• 测试和验证
  

• 在调整 JVM 参数后，进行压力测试和性能测试，验证调优效果。
  
• 使用工具（如 JMeter、Gatling）模拟高并发场景，检查体系的稳定性和性能。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/)

Powered by Discuz! X3.4