<返回更多

40道JVM面试题！

2023-07-26  今日头条  程序员的秃头之路
加入收藏

1、垃圾回收

有哪些垃圾收集算法？

在JVM（JAVA虚拟机）中，垃圾回收主要使用了以下几种算法：

1、 标记-清除算法（Mark-Sweep）：这是最基本的垃圾回收算法。它分为两个阶段：标记阶段和清除阶段。在标记阶段，GC会遍历所有的对象，对所有存活的对象进行标记；在清除阶段，GC会清除所有未被标记（即不再使用）的对象。这种方法的缺点是会产生大量的内存碎片。

 

 

 

2、 复制算法（Copying）：这种算法将可用内存分为两块，每次只使用其中一块。当这一块内存用完了，就将还存活的对象复制到另一块上面，然后再把已使用过的内存空间一次清理掉。这种做法的好处是简单且没有内存碎片，但是代价是内存利用率低。

 

 

 

3、 标记-整理算法（Mark-Compact）：这种算法是标记-清除算法的改进版，它在标记和清除的基础上增加了整理的过程。在标记和清除之后，它会将所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。

 

 

 

4、 分代收集算法（Generational Collection）：这种算法的基本思想是根据对象存活的生命周期将内存划分为几块。一般情况下，将堆分为新生代和老年代，这样我们就可以根据各年代的特点选择合适的垃圾回收算法。比如，新生代中每次垃圾回收都会有大量对象死去，只有少量存活，那就选用复制算法，只需要付出少量存活对象的复制成本就可以完成收集。而老年代中因为对象存活率高、没有额外空间对它进行分配担保，就必须使用标记-清理或者标记-整理算法进行回收。

以上就是JVM中常见的几种垃圾回收算法。需要注意的是，实际的JVM实现（比如HotSpot）在实践中会根据具体情况采用不同的垃圾回收算法，甚至是几种算法的组合，以达到最优的垃圾回收效果。例如，HotSpot的新生代默认使用复制算法，老年代使用标记-整理算法。

知道哪几种垃圾收集器，各自的优缺点

JVM 提供了多种垃圾收集器，每种收集器都有各自的特点和适用场景。以下是一些典型的垃圾收集器：

1、 Serial Collector：串行收集器，适用于单核 CPU 的环境。它在新生代使用复制算法，在老年代使用标记-整理算法。这种收集器在进行垃圾回收时会暂停所有的用户线程，因此并不适用于要求低停顿时间的应用。

2、 Parallel Collector：并行收集器，也称为吞吐量优先收集器。它在新生代使用复制算法，在老年代使用标记-整理算法。Parallel Collector 可以使用多个线程并行地执行垃圾回收任务，以提高吞吐量。但是，它在进行垃圾回收时同样会暂停所有的用户线程。

3、 Concurrent Mark Sweep（CMS）收集器：CMS 收集器是一种并发收集器，主要针对老年代。它在新生代使用复制算法，在老年代使用标记-清除算法。CMS 收集器的目标是减少垃圾回收引起的停顿时间。它的垃圾回收过程包括以下四个阶段：

CMS 收集器的优点是降低了停顿时间，但缺点是对 CPU 资源要求较高，并且由于使用了标记-清除算法，可能导致内存碎片问题。

4、 G1（Garbage-First）收集器：G1 收集器是一种面向服务器应用的垃圾收集器，旨在实现高吞吐量和低停顿时间。G1 收集器将堆内存划分为多个大小相等的区域（Region），每个区域可能是 Eden 区、Survivor 区或者 Old 区。G1 收集器在新生代使用复制算法，在老年代使用标记-整理算法。它的垃圾回收过程包括以下阶段：

G1 收集器的优点是在实现高吞吐量的同时，可以控制停顿时间，避免长时间的 Full GC。此外，由于 G1 使用了标记-整理算法，可以减少内存碎片问题。缺点是 G1 收集器对系统资源要求较高，可能导致各个阶段的 CPU 和内存开销增加。

总结： CMS 和 G1 收集器都是为了实现低停顿时间的垃圾收集。CMS 收集器主要针对老年代，使用标记-清除算法，可能导致内存碎片问题。G1 收集器通过将堆划分为多个区域并使用标记-整理算法，既实现了低停顿时间，又解决了内存碎片问题。尽管这两种收集器都能提高应用程序的响应性，但它们对系统资源的要求较高，可能导致吞吐量下降。选择合适的垃圾收集器需要根据应用程序的具体需求和资源限制进行权衡。

G1垃圾回收器的一些重要参数

 

 

 

G1（Garbage-First）垃圾回收器是一种面向服务器的垃圾回收器，主要用于多核处理器和大内存环境。G1垃圾回收器以高预测性的停顿时间，及高整体吞吐量为设计目标。以下是一些G1垃圾回收器的重要参数：

1、 -XX:+UseG1GC：启用G1垃圾回收器。

2、 -XX:MaxGCPauseMillis：设置G1垃圾回收期间的最大停顿时间（以毫秒为单位）。G1垃圾回收器将尽力保证实际停顿时间不超过这个值。

3、 -XX:G1HeapRegionSize：设置G1的堆区域大小。G1将堆划分为多个相等的区域，这个参数用于设置每个区域的大小。其值应是1M到32M之间，并且是2的幂。

4、
-XX:InitiatingHeapOccupancyPercent：设置启动并发标记周期的堆占用百分比。当老年代的占用率超过这个值时，就会启动并发标记周期。默认值是45。

5、 -XX:G1ReservePercent：设置作为备用的堆内存百分比，用于在并发周期结束时确保有足够的空闲空间。默认值是10。

6、 -XX:ParallelGCThreads：设置并行垃圾回收的线程数。默认值与CPU的数量相同。

7、 -XX:ConcGCThreads：设置并发垃圾回收的线程数。默认值是ParallelGCThreads的1/4。

8、 -XX:G1NewSizePercent：设置新生代最小值占整个Java堆的百分比，G1会根据运行时的情况动态调整新生代的大小，但不会低于G1NewSizePercent设置的值。默认值是5%。

9、 -XX:G1MaxNewSizePercent：设置新生代最大值占整个Java堆的百分比，默认值是60%。

10、 -XX:G1MixedGCCountTarget：设置混合垃圾回收的目标次数，即在并发周期结束后，还可以进行多少次混合垃圾回收。默认值是8。

以上是一些G1垃圾回收器的重要参数，每个参数都可以通过JVM启动时的命令行参数进行设置。在实际使用时，需要根据应用程序的特性和运行环境的情况，调整这些参数的值，以获取最好的垃圾回收性能。

怎么设置垃圾回收器和参数

这些参数的设置通常是在启动JVM时作为命令行参数传入的。如果是使用Spring Boot的话，可以在java -jar命令后面添加这些参数。

假设有一个Spring Boot的应用，它的JAR包名为my-App.jar，想使用G1垃圾回收器，并设置最大的垃圾收集停顿时间为200毫秒，可以这样设置：

java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -jar my-app.jar

在这个例子中，-XX:+UseG1GC启用了G1垃圾回收器，-XX:MaxGCPauseMillis=200设置了最大的垃圾收集停顿时间为200毫秒。

这些设置是针对单个JVM实例的，也就是说，它们只影响正在启动的那个Java应用。如果在一台服务器上运行了多个Java应用，需要为每个应用分别设置这些参数。

如果希望在一台服务器上统一设置这些参数，可能需要创建一个启动脚本，然后在这个脚本中为所有的Java应用指定相同的参数。但是，请注意，不是所有的应用都需要相同的参数设置，不同的应用可能有不同的性能特性和需求。因此，在实际操作中，可能需要根据每个应用的特性和需求，适当地调整这些参数的值。

新生代，老年代，永久代，元空间 的区别

在Java虚拟机（JVM）中，堆内存是用于存放Java对象的地方，它被划分为不同的区域或"代"，这些代基于对象的生命周期进行划分。以下是这些代的详细解释：

1、 新生代（Young Generation）：新创建的对象首先被放置在新生代。新生代又被划分为一个Eden区和两个Survivor区（通常被称为Survivor From和Survivor To）。大部分情况下，对象在Eden区中被创建，然后通过几轮的垃圾收集（Minor GC）在Survivor区之间移动。如果一个对象在新生代中存活时间足够长（达到一定的年龄阈值），它就会被晋升（promote）到老年代。

2、 老年代（Old Generation）：长时间存活的对象，或者已经从新生代晋升过来的对象会被存放在老年代。老年代中的垃圾收集被称为Major GC，它的发生频率通常比Minor GC低，但每次收集的时间通常较长。

3、 永久代（Permanent Generation）：在Java 7及更早的版本中，JVM使用永久代来存储类的元数据，如类的名称、字段和方法等。请注意，永久代并不是Java堆的一部分，因此它有自己的内存空间限制。永久代中的垃圾收集被称为Full GC。

4、 元空间（Metaspace）：在Java 8中，永久代被元空间所替代。和永久代不同，元空间并不在物理上存在于Java堆中，因此，它不受Java堆大小的限制，而是受系统的实际内存大小限制。元空间主要用于存储类的元数据。

这就是Java堆中各个区域的基本概念。它们的主要目标是优化垃圾收集性能，因为不同的垃圾收集器可以根据对象的生命周期和区域的特性采用不同的策略。

对象是怎么从年轻代进入老年代的？

在Java虚拟机（JVM）中，新创建的对象首先会被分配到新生代（Young Generation）的Eden区。当Eden区满了之后，就会触发一次Minor GC（小型垃圾回收）。

在Minor GC中，JVM会清理掉Eden区中无用（不再被引用）的对象，并将还存活（仍然被引用）的对象转移到Survivor区。Survivor区包括两部分，S0和S1，一开始，所有存活的对象会被复制到其中一个Survivor区（如S0）。

在下一次Minor GC时，Eden区和已经占用的Survivor区（如S0）中仍然存活的对象会被复制到另一个Survivor区（如S1），并清空Eden区和第一个Survivor区（如S0）。

这个过程每次Minor GC都会重复进行，Survivor区中的对象在每次Minor GC后如果仍然存活，并且年龄（即被复制的次数）达到一定阈值（默认15次，可通过-XX:MaxTenuringThreshold参数调整），那么这个对象就会被晋升到老年代（Old Generation）。

此外，如果Survivor区无法容纳在一次Minor GC中Eden区和另一个Survivor区（如S0）中存活下来的对象，或者大对象（大于Survivor区一半的对象）直接分配不进Survivor区，这些对象也会直接被分配到老年代。

所以，一个对象从新生代进入老年代，要么是因为它的年龄达到了阈值，要么是因为Survivor区无法容纳它，或者它是一个大对象。

CMS分为哪几个阶段?（CMS已经弃用，不必深究）

CMS（Concurrent Mark Sweep）垃圾回收器是一种以获取最短回收停顿时间为目标的垃圾回收器。它主要针对老年代进行垃圾回收。CMS垃圾回收过程大致分为以下四个阶段：

1、 初始标记（Initial Mark）：这个阶段是"Stop The World"阶段，也就是说在这个阶段，应用线程会被暂停以允许垃圾收集器线程工作。在这个阶段，垃圾收集器会标记所有从GC Roots直接可达的对象。

2、 并发标记（Concurrent Mark）：在此阶段，垃圾收集器会在应用线程运行的同时，遍历所有从GC Roots可达的对象。由于在此阶段应用线程和垃圾收集器线程并发运行，因此这个阶段不需要停止应用线程。

3、 重新标记（Remark）：这个阶段也是"Stop The World"阶段。由于在并发标记阶段，应用线程和垃圾收集器线程是并发运行的，因此可能会有一些引用关系发生了改变的对象没有被正确标记。重新标记阶段的目的就是修正这些标记错误。

4、 并发清除（Concurrent Sweep）：在此阶段，垃圾收集器会清除那些被标记为垃圾的对象。这个阶段也是在应用线程运行的同时进行的，不需要停止应用线程。

CMS垃圾回收器的主要目标是尽可能减少"Stop The World"的时间，以达到减少应用的响应时间的目标。但是，CMS垃圾回收器也有一些缺点，比如它无法处理浮动垃圾，可能会导致内存碎片化，以及在并发清除阶段可能会与应用线程竞争CPU等。因此，在选择使用CMS垃圾回收器时，需要根据应用的特性和需求进行权衡。

CMS都有哪些问题？

CMS (Concurrent Mark Sweep) 垃圾回收器是一种以获取最短回收停顿时间为目标的垃圾回收器。虽然 CMS 回收器在降低停顿时间方面做得很好，但也存在一些问题和挑战：

1、 内存碎片化：CMS 采用的是标记-清除的算法，这种算法会导致内存空间碎片化。清理出来的空间可能是不连续的，当需要分配大对象时，无法找到足够的连续内存，会触发 Full GC。

2、 浮动垃圾问题：在 CMS GC 的并发清理阶段，应用线程还在运行并且可能产生新的垃圾，这部分垃圾称为浮动垃圾。由于 CMS 并发清理阶段之后并没有其他的 STW 操作，所以这部分浮动垃圾只能等到下一次 GC 时进行清理。

3、 并发阶段可能会导致应用线程变慢：CMS 的收集线程在并发阶段会和应用线程一起占用 CPU，如果 CPU 资源紧张，可能会导致应用线程运行速度变慢。

4、 对 CPU 资源敏感：CMS 默认启动的回收线程数是 (CPU数量+3)/4，当 CPU 核数较多时，CMS 并发执行的回收线程数也就多，这样可能会对应用产生较大的影响。

5、 无法处理晋升失败：如果在 Minor GC 期间，Survivor 空间不足以容纳新晋升的对象，这些对象会直接晋升到老年代，如果老年代也无法容纳这些对象，就会出现晋升失败（promotion fAIled）。CMS 无法处理晋升失败，只能触发 Full GC。

由于以上问题，Java 9 中引入了另一种低延迟的垃圾回收器，叫做 G1（Garbage First）垃圾回收器，它克服了 CMS 的一些问题，例如内存碎片化和处理晋升失败等。

JVM垃圾回收时候如何确定垃圾？什么是GC Roots？

在JVM中，判断一个对象是否为"垃圾"，主要依据的是该对象是否还被引用。如果一个对象没有任何引用指向它，那么这个对象就可以被认为是垃圾，可以被垃圾收集器回收。

然而，在实际操作中，直接查找每个对象的引用情况是非常低效的，因此，JVM采用了一种反向的思路来判断对象是否为垃圾，这就涉及到了"GC Roots"的概念。

GC Roots（垃圾回收根节点）是一组必须活跃的引用，垃圾收集器在进行垃圾收集时，会从GC Roots开始，遍历这些根节点，然后通过引用链的方式，查找出所有从GC Roots开始可以访问到的对象，这些对象被认为是"非垃圾"对象。反之，那些从GC Roots开始无法通过引用链访问到的对象，就被认为是"垃圾"，可以被回收。

常见的GC Roots对象包括：

1、 虚拟机栈（栈帧中的本地变量表）中引用的对象：也就是当前线程的局部变量和输入参数。

2、 方法区中类静态属性引用的对象：这些是类的静态变量。

3、 方法区中常量引用的对象：这些是被final修饰的常量。

4、 本地方法栈中JNI（即通常说的Native方法）引用的对象。

以上这些都作为GC Roots，JVM从这些节点出发，通过引用关系，找出所有被引用的对象，未被引用的对象就被视为是可回收的垃圾。

能够找到 Reference Chain 的对象，就一定会存活么？

一般来说，从GC Roots开始可以通过引用链找到的对象，都是可达的（reachable），这些对象不会被垃圾回收器视为垃圾进行回收。这是因为它们可能还会在程序运行过程中被使用，因此需要保留。

然而，这并不意味着所有可达的对象都是"活动的"或"需要的"。在某些情况下，一些实际上不再需要的对象可能仍然是可达的，这种情况通常被称为"内存泄漏"（Memory Leak）。例如，如果一个集合对象（如ArrayList或HashMap）在全局范围内可达，并且一直在添加新的元素，但是这些元素在被添加之后就不再被使用，那么这些元素实际上是不需要的，但是它们仍然是可达的，因此不会被垃圾回收器回收，这就造成了内存泄漏。

此外，Java还提供了弱引用（Weak Reference）、软引用（Soft Reference）和虚引用（Phantom Reference）这三种特殊的引用类型，这些引用类型所指向的对象即使是可达的，也可能被垃圾回收器回收。这为处理那些需要通过某种方式与垃圾收集器进行交互的复杂场景提供了可能性。

总的来说，从GC Roots开始可以通过引用链找到的对象，通常都是存活的，不会被垃圾回收器回收，但是这并不绝对。在某些特殊情况下，这些对象可能仍然会被回收，或者可能因为内存泄漏等问题而需要被手动处理。

新生代，老年代，永久代，元空间 内存分配占比多少

这些区域的默认内存占比并非固定，而是依赖于JVM的具体实现以及配置。但在HotSpot虚拟机中，一种常见的默认配置是：

1、 新生代（Young Generation）：新生代通常占据堆的1/3。新创建的对象首先被放置在新生代。新生代又被划分为一个Eden区和两个Survivor区（Survivor From和Survivor To）。通常默认配置是Eden区占新生代的8/10，两个Survivor区各占新生代的1/10。

2、 老年代（Old Generation）：老年代通常占据堆的2/3。长时间存活的对象，或者已经从新生代晋升过来的对象会被存放在老年代。

3、 永久代（Permanent Generation）：在Java 7及更早的版本中，JVM使用永久代来存储类的元数据，如类的名称、字段和方法等。永久代的默认大小根据具体的JVM实现和配置而变，但通常不会太大。

4、 元空间（Metaspace）：在Java 8中，永久代被元空间所替代。元空间并不在物理上存在于Java堆中，因此，它不受Java堆大小的限制，而是受系统的实际内存大小限制。元空间主要用于存储类的元数据。

这只是一种常见的默认配置，并且可以根据应用的需求来调整这些区域的大小。例如，如果应用创建了大量的短暂的小对象，可能想要增加新生代的大小；如果应用需要加载大量的类，可能想要增加永久代或元空间的大小。

JVM 中一次完整的 GC 流程是怎样的，对象如何晋升到老年代

一次完整的 GC 流程涉及到 Java 堆内存的划分以及不同类型的垃圾回收。以下是详细的解释：

1、 Java 堆内存划分：

Java 堆内存被划分为新生代（Young Generation）和老年代（Old Generation）。新生代包括 Eden 区和两个 Survivor 区（S0 和 S1）。新创建的对象首先分配在 Eden 区，经过一定次数的垃圾回收后，存活的对象会被移动到 Survivor 区，最后晋升到老年代。

2、 Minor GC：

Minor GC（小型垃圾回收）主要发生在新生代。当 Eden 区的空间不足以分配新的对象时，Minor GC 会被触发。Minor GC 的主要任务是清理 Eden 区中不再被引用的对象，并将存活的对象移动到 Survivor 区（S0 或 S1）。如果 Survivor 区已满，那么达到一定年龄阈值的对象会被晋升到老年代。Minor GC 通常比较快，因为新生代的大部分对象生命周期较短。

3、 Major GC：

Major GC（大型垃圾回收）主要发生在老年代。当老年代的空间不足以存储晋升的对象时，Major GC 会被触发。与 Minor GC 不同，Major GC 需要回收整个老年代区域，包括长时间存活的对象和不再被引用的对象。Major GC 通常比 Minor GC 要慢很多，因为需要回收更多的内存区域。

4、 Full GC：

Full GC（全面垃圾回收）是一种涉及整个堆内存的垃圾回收，包括新生代、老年代和元空间（Java 8 开始，替代了持久代）。Full GC 通常在以下情况下触发：

Full GC 的开销相对较大，因为它需要回收整个堆内存和元空间。在进行 Full GC 期间，应用程序的吞吐量会受到影响，因此应尽量避免 Full GC 的发生。

5、 转化流程：

为了减少 GC 开销并提高应用程序性能，可以通过调整 JVM 参数来优化堆内存的划分以及垃圾回收策略。例如，可以根据对象的生命周期和内存使用情况调整新生代、老年代和元空间的大小。此外，可以选择适当的垃圾回收器，如 G1、CMS 或 Parallel GC，以满足特定应用场景的需求。

MinorGC，MajorGC、FullGC都什么时候发生？

在Java虚拟机（JVM）中，垃圾收集（GC）主要有Minor GC、Major GC和Full GC三种。下面是它们各自发生的情况：

1、 Minor GC：Minor GC主要在新生代（Young Generation）中发生。当新生代的Eden区（其中存放新创建的对象）满时，就会触发Minor GC。Minor GC会清理掉Eden区无用的对象，并将还存活的对象转移到Survivor区。如果Survivor区也满了，那么存活的对象会被移动到老年代（Old Generation）。

2、 Major GC：Major GC主要在老年代中发生。当老年代空间不足时，就会触发Major GC。Major GC的执行时间通常比Minor GC要长，因为需要清理的对象更多。在Major GC发生时，JVM通常会暂停所有的应用线程，因此也被称为STW（Stop The World）。

3、 Full GC：Full GC是对整个堆（包括新生代和老年代）进行清理。当系统在进行Full GC时，所有的应用线程都会被暂停。Full GC的触发条件比较多，包括老年代空间不足、永久代空间不足（Java 8之前）、显式调用System.gc()、上一次GC之后Heap的剩余空间不足等。Full GC的执行时间最长，应当尽可能减少Full GC的发生。

注意：GC的性能影响和JVM的具体垃圾收集器（如Serial、Parallel、CMS、G1等）有关，不同的垃圾收集器在GC过程中的行为和性能可能会有所不同。所以在实际使用中，需要根据应用的实际情况选择合适的垃圾收集器，以达到最好的性能效果。

jdk默认垃圾收集器是啥

Java的默认垃圾回收器（Garbage Collector, GC）根据JDK的版本和是否是服务器版有所不同。

、 可以通过以下命令来检查Java应用程序正在使用哪种垃圾回收器：

java -XX:+PrintCommandLineFlags -version

在这个命令的输出中，-XX:+Use*GC标志将告诉哪种垃圾回收器正在被使用（*表示垃圾回收器的名称）。例如，如果看到-XX:+UseG1GC，那么Java应用程序就是在使用G1垃圾回收器。

这些信息可能会随着JDK的不同版本和配置有所变化，因此，建议检查JDK发行版的具体文档，以获取最准确的信息。

GC日志的real、user、sys是什么意思？

在Java的垃圾收集（GC）日志中，real、user、sys都是用来衡量时间的指标，它们的含义如下：

1、 real：这是实际经过的墙钟时间。也就是说，从垃圾收集开始到垃圾收集结束所经过的真实时间。

2、 user：这是所有运行在用户模式下的CPU时间的总和。这包括了垃圾收集线程在用户模式下运行的时间。

3、 sys：这是在内核模式下运行的CPU时间的总和。当Java进程需要执行诸如内存分配之类的系统调用时，它会切换到内核模式。

在理想情况下，我们希望real时间与user和sys时间的总和接近，因为这意味着垃圾收集线程能够充分利用CPU资源。如果real时间远大于user和sys时间的总和，那么可能说明垃圾收集线程在等待某些资源，比如内存或者磁盘IO。

另外，如果sys时间占总时间的比例过高，那么可能说明系统调用的开销过大，这可能是由于频繁的内存分配或者其他的系统调用引起的。

需要注意的是，这些时间指标都是近似值，可能会受到操作系统的调度策略和其他因素的影响。

2、内存

JVM有哪些内存区域？(JVM的内存布局是什么？)

 

 

JVM（Java 虚拟机）内存模型描述了 Java 程序在运行过程中如何使用内存。JVM 内存模型主要包括以下部分：

1、 方法区（Method Area）

方法区用于存储已加载的类信息（如类名、访问修饰符、常量池等）、静态变量和常量。方法区是所有线程共享的资源。

可能存在的问题：如果加载了过多的类或者常量池过大，可能导致方法区内存耗尽，抛出
java.lang.OutOfMemoryError: PermGen space（Java 7 及之前）或
java.lang.OutOfMemoryError: Metaspace（Java 8 及之后）异常。

2、 堆（Heap）

堆是 JVM 运行时数据区的主要部分，用于存储对象实例和数组。堆是线程共享的资源，它被划分为年轻代（Young Generation）和老年代（Old Generation）。年轻代包括一个 Eden 区和两个 Survivor 区（S0 和 S1），用于存储新创建的对象。当对象在 Eden 区达到一定年龄后，它们会被移到 Survivor 区或老年代。老年代用于存储存活时间较长的对象。

可能存在的问题：如果创建了过多的对象或者对象没有被及时回收，可能导致堆内存耗尽，抛出
java.lang.OutOfMemoryError: Java heap space 异常。

 

 

 

3、 栈（Stack）

栈用于存储局部变量、方法调用和返回地址等信息。每个线程都有一个独立的栈，用于存储该线程的方法调用栈帧。当一个方法被调用时，一个新的栈帧被压入栈中；当方法返回时，相应的栈帧被弹出。

可能存在的问题：如果存在过深的方法调用链或者递归调用，可能导致栈内存耗尽，抛出
java.lang.StackOverflowError 异常。

4、 本地方法栈（Native Method Stack）

本地方法栈用于存储本地方法（native 方法）的调用信息。每个线程都有一个独立的本地方法栈。

可能存在的问题：与栈类似，本地方法栈也可能因为过深的方法调用链或者递归调用导致内存耗尽，抛出
java.lang.StackOverflowError 或
java.lang.OutOfMemoryError 异常。

5、 程序计数器（Program Counter Register）

程序计数器用于存储当前线程正在执行的字节码指令的地址。每个线程都有一个独立的程序计数器。如果当前线程正在执行的是 Java 方法，程序计数器记录的是正在执行的虚拟机字节码指令的地址；如果当前线程正在执行的是本地方法，则程序计数器的值为 undefined。

可能存在的问题：程序计数器本身不容易出现问题，因为它的内存分配和回收是随线程的创建和销毁自动进行的。但程序计数器关联的字节码指令可能会导致一些问题，例如：死循环、跳转到错误的指令地址等。这些问题需要通过检查代码逻辑来解决。

JVM 内存模型中的各个模块都承担着特定的功能和责任。为了避免内存问题，需要合理地分配和管理内存资源。例如，可以通过调整 JVM 参数来设置堆内存大小、年轻代和老年代的比例等。同时，也需要关注代码逻辑，避免不必要的递归调用、死循环、内存泄漏等问题，从而确保程序的稳定运行。

Java的内存模型是什么？（JMM是什么？）

Java 内存模型（Java Memory Model, JMM）是一个抽象的概念，它定义了 Java 程序如何在内存中存储、操作和传递数据。Java 内存模型主要关注以下几个方面：

1、 原子性（Atomicity）：原子性是指一个操作要么完全执行，要么完全不执行。Java 内存模型确保了基本的读、写和赋值操作是原子性的。但对于 64 位数据类型（如 long 和 double），JMM 允许非原子性的读写操作，可能导致数据的不一致。

2、 可见性（Visibility）：可见性是指一个线程对共享变量的修改能够被其他线程及时看到。Java 内存模型通过使用内存屏障（memory barrier）和定义一系列的内存访问规则来确保线程之间的可见性。

3、 顺序性（Ordering）：顺序性是指程序在执行过程中遵循代码的顺序进行。但是，为了优化性能，编译器、处理器和运行时系统可能对代码进行重排序。Java 内存模型通过定义一定的顺序规则来确保在多线程环境下，代码的执行不会导致错误的结果。

4、 一致性（Consistency）：一致性是指程序在执行过程中，对内存中的数据操作遵循一定的规则和顺序。Java 内存模型通过定义先行发生（happens-before）规则来确保内存操作的一致性。先行发生规则定义了两个操作之间的偏序关系，使得在多线程环境下，可以预测操作的执行顺序。

Java 内存模型主要关注多线程环境下的内存操作行为。它提供了一套规则和原则，以确保程序在多线程环境中的正确性、可靠性和可预测性。了解 Java 内存模型对于编写高效且正确的多线程程序至关重要，尤其是在处理线程同步和数据共享时。

什么情况下会发生栈内存溢出

栈内存溢出（StackOverflowError）是一种运行时错误，通常发生在程序中存在过深的方法调用或者递归调用导致栈空间耗尽。

1、 栈定义：

栈（Stack）是一种后进先出（LIFO）的数据结构，用于存储局部变量、方法调用和返回地址等信息。在 Java 程序中，每个线程都有一个栈，用于存储该线程的方法调用栈帧。当一个方法被调用时，一个新的栈帧被压入栈中；当方法返回时，相应的栈帧被弹出。栈帧中包含了方法的局部变量、临时数据和方法返回地址等信息。

2、 为什么会发生栈内存溢出：

栈内存溢出通常是由于以下原因导致的：

当栈空间不足以容纳更多的栈帧时，就会发生栈内存溢出错误。

3、 相关配置参数：

在 Java 虚拟机（JVM）中，可以通过一些参数配置线程栈的大小。以下是一些常见的参数：

调整这些参数可以影响栈空间的大小，但请注意，增加栈大小并不能解决代码中存在的栈内存溢出问题，而只是减轻了风险。为了避免栈内存溢出，需要审查代码以确保递归调用有正确的终止条件，同时避免过深的方法调用链。

JVM 内存模型的相关知识了解多少，比如重排序，内存屏障，happen-before，主内存，工作内存。

JVM 内存模型（Java Memory Model，JMM）主要涉及到并发编程中的一些重要概念，如重排序、内存屏障、happens-before、主内存和工作内存等。以下是这些概念的详细解释：

1、 重排序：为了提高程序执行的效率，编译器和处理器可能会对指令进行重新排序。但是，在多线程环境中，指令的重排序可能会导致意料之外的结果。

2、 内存屏障：内存屏障（Memory Barrier）是一种硬件指令，用于防止指令重排序。它可以保证屏障之前的指令不会被排在屏障之后，屏障之后的指令不会被排在屏障之前。

3、 happens-before：这是一种偏序关系，用于描述程序中的两个操作的顺序。如果操作 A happens-before 操作 B，那么 A 的结果对 B 是可见的，且 A 不会被重排序到 B 之后。

4、 主内存和工作内存：在 JMM 中，所有的变量都存储在主内存中，每个线程还有自己的工作内存，用于保存主内存中变量的副本。线程对变量的所有操作都在工作内存中进行，然后再同步回主内存。

现在，我们通过一个 volatile 关键字的例子来解释这些概念：

public class VolatileDemo {
    volatile int i = 0;

    public void update() {
        i++;
    }
}

在这个例子中，i 是一个 volatile 变量。当我们在多线程环境中调用 update 方法时，以下是发生的事情：

这个例子展示了如何使用 volatile 关键字来保证变量在多线程环境中的可见性和顺序一致性。但需要注意的是，volatile 不能保证复合操作的原子性。在上述例子中，i++ 是一个复合操作，包括读取 i 的值、对 i 加一和写入 i 的新值三个步骤。尽管 volatile 可以保证每个步骤的可见性和顺序一致性，但是在多线程环境中，这三个步骤仍然可能被其他线程的操作打断，导致 i++ 操作的结果不正确。要保证复合操作的原子性，我们需要使用同步机制，如 synchronized 关键字或 java.util.concurrent 包中的原子类。

总的来说，JVM 内存模型定义了 Java 程序在多线程环境中如何正确、安全地访问共享变量。理解 JMM 中的重排序、内存屏障、happens-before、主内存和工作内存等概念，对于编写高效、可靠的并发程序至关重要。

JVM 内存为什么要分成新生代，老年代，持久代。新生代中为什么要分为 Eden 和 Survivor。

JVM 内存中的堆（Heap）主要用于存储对象实例和数组。为了提高内存管理的效率，JVM 将堆内存划分为新生代（Young Generation）、老年代（Old Generation）和持久代（PermGen，Java 8 开始被元空间 MetaSpace 替代）。这种划分基于分代收集算法，它根据对象的生命周期对内存进行分区管理。分代收集算法的核心思想是：大部分对象生命周期较短，只有少部分对象存活时间较长。

1、 Java 堆：

Java 堆是 JVM 内存中的主要部分，用于存储对象实例和数组。它被划分为新生代和老年代。

2、 新生代划分：

新生代是 Java 堆的一部分，主要用于存储新创建的对象。新生代被进一步划分为 Eden 区和两个 Survivor 区（S0 和 S1）。

3、 转化和参数配置：

当新生代中的对象经过一定次数的垃圾回收后（即对象达到一定年龄），这些对象会被移动到老年代。这个过程称为晋升（Promotion）。

以下是一些与新生代相关的 JVM 参数：

4、 为什么要划分新生代、老年代和持久代：

这种划分主要是为了提高垃圾回收的效率。根据对象的生命周期，大部分对象很快就不再被引用并且可以被回收。只有少数对象需要长期保留。这种观察结果导致了分代收集算法的产生。

新生代用于存放新创建的对象，垃圾收集器主要关注新生代。由于新生代中的大部分对象生命周期较短，可以快速回收。频繁进行新生代的垃圾回收可以有效减少老年代的垃圾回收次数，提高垃圾回收效率。

将 Eden 区和 Survivor 区分开的主要原因是为了解决对象在新生代中的内存碎片问题。通过在 Survivor 区之间来回复制对象，可以避免内存碎片的产生，同时减少内存整理的开销。

老年代用于存放长时间存活的对象。

什么情况会造成元空间溢出？

Java的元空间（Metaspace）用于存储加载到内存中的类的元数据信息，如类名、访问修饰符、常量池、字段描述、方法描述等。元空间在Java 8中取代了之前版本的永久代（PermGen）。

元空间的大小并不是固定的，而是根据需要动态地从本地内存中分配空间。默认情况下，元空间的大小只受限于本地内存的大小。但是，我们可以通过-XX:MetaspaceSize和-XX:MaxMetaspaceSize参数来设置元空间的初始大小和最大大小。

以下是一些可能导致元空间溢出的情况：

1、 加载过多的类：如果应用程序加载了大量的类，可能会使元空间填满。这种情况可能在使用大型框架或者服务器容器的应用中出现，因为这些应用可能会加载大量的类。也可能在动态生成并加载类的应用中出现，比如某些脚本语言的Java实现。

2、 类加载器泄漏：在Java中，类的生命周期是和加载它们的类加载器（ClassLoader）绑定的。当一个类加载器被回收时，它加载的所有类也会被卸载。因此，如果一个类加载器没有被回收（比如被某些对象引用了），它加载的所有类也会一直存在，这可能会导致元空间溢出。

3、 设置的最大元空间大小太小：如果使用了-XX:MaxMetaspaceSize参数，并且设置的值太小，也可能会导致元空间溢出。

出现元空间溢出时，JVM会抛出
java.lang.OutOfMemoryError: Metaspace错误。为了解决这个问题，我们需要分析应用程序的类加载情况，找出为什么会加载过多的类或者类加载器没有被回收。此外，也可以考虑增大最大元空间大小，但是这可能会增大应用程序的内存占用。

什么时候会造成堆外内存溢出？

在Java中，堆外内存（Off-Heap Memory）主要是指不由Java虚拟机（JVM）直接管理的内存。一般来说，有以下几种情况可能导致堆外内存溢出：

1、 直接内存使用过多：在Java中，我们可以通过
java.nio.ByteBuffer.allocateDirect()方法分配直接内存（Direct Memory）。直接内存不是由JVM的垃圾回收器管理的，因此，如果我们分配了过多的直接内存，并且没有及时释放，可能会导致堆外内存溢出。注意，直接内存的大小默认和Java堆的最大大小一样，可以通过-XX:MaxDirectMemorySize参数来设置。

2、 JNI使用过多的内存：Java本地接口（Java Native Interface，JNI）允许Java代码调用本地方法，这些本地方法可能会分配额外的内存。如果这些本地方法分配了过多的内存，并且没有及时释放，也可能会导致堆外内存溢出。

3、 线程过多：每个线程在被创建时，都会有一个线程栈被分配。线程栈的大小默认是1MB（这个大小可以通过-Xss参数设置）。因此，如果创建了过多的线程，可能会导致堆外内存溢出。

4、 类元数据区域使用过多：在Java 8及以上版本中，类的元数据（如类的名字、字段和方法等信息）被存储在Metaspace中。Metaspace默认使用的是堆外内存，如果加载了过多的类，可能会导致Metaspace使用过多的内存，从而导致堆外内存溢出。注意，Metaspace的大小默认是不限制的，但是可以通过-XX:MaxMetaspaceSize参数来设置。

以上就是可能导致堆外内存溢出的一些常见情况。要解决这些问题，我们需要对JVM的内存管理有深入的了解，同时也需要使用一些工具和技巧来排查和解决问题。

有什么堆外内存的排查思路？

堆外内存是指在Java虚拟机（JVM）管理的堆内存之外的内存。以下是一些排查堆外内存问题的思路：

1、 确认是否存在堆外内存问题：首先，我们需要确认是否存在堆外内存问题。比如，我们可以通过查看操作系统的进程内存使用情况，比较JVM的堆内存和进程的总内存使用情况，来判断是否有大量的堆外内存被使用。

2、 分析堆外内存的使用情况：如果确认存在堆外内存问题，那么我们就需要分析堆外内存的使用情况。常见的堆外内存使用包括直接内存（Direct Memory，通过ByteBuffer.allocateDirect分配）、线程栈、类元数据区（Metaspace或PermGen）、JNI代码等。我们可以使用工具（如jmap、jconsole、VisualVM、MAT等）或JVM参数（如-XX:NativeMemoryTracking、-XX:+PrintFlagsFinal等）来分析这些区域的内存使用情况。

3、 定位具体的内存使用位置：在得到了内存使用的概况之后，我们需要进一步定位具体的内存使用位置。这可能需要分析代码，查找可能使用了大量堆外内存的地方。比如，我们可以查找是否有大量的DirectByteBuffer被创建但没有被释放，或者是否有大量的线程被创建等。

4、 解决问题：在找到了问题的位置之后，我们就可以尝试解决问题。比如，我们可以尝试减少DirectByteBuffer的使用，或者优化线程的使用等。如果问题出在JNI代码上，可能需要修改或优化JNI代码。

5、 持续监控：在解决问题之后，我们需要持续监控内存使用情况，确认问题已经被解决，并防止未来出现类似的问题。

总的来说，排查堆外内存问题需要对JVM的内存管理有深入的了解，同时也需要使用一些工具和技巧。并且，由于堆外内存的管理比较复杂，所以排查和解决问题可能需要一定的时间和精力。

为什么要将堆内存分区？

Java的堆内存被分为不同的区域，包括年轻代（Young Generation）、老年代（Old Generation）和元空间（Metaspace，JDK 8引入，替代了之前版本中的永久代）。这种分区的设计主要基于两个观察结果：

1、 大部分对象都是短暂存在的：这是由Peter Denning在他的论文"The Working Set Model for Program Behavior"中提出的弱分代假说得出的结论。也就是说，新创建的大部分对象都会很快变成垃圾，比如方法中的临时变量。因此，通过将新创建的对象放在年轻代中，可以快速回收这些短暂存在的对象，从而避免了全堆的垃圾收集。

2、 短暂存在的对象和长时间存在的对象可能有不同的垃圾收集需求：对于短暂存在的对象，我们需要一种能够快速回收大量对象的垃圾收集算法。对于长时间存在的对象，我们需要一种能够有效处理内存碎片化的垃圾收集算法。通过将堆内存分区，我们可以针对不同区域的特性选择最合适的垃圾收集算法。

除此之外，将堆内存分区还可以减少垃圾收集时的暂停时间。因为进行一次全堆的垃圾收集可能需要停止所有的应用线程，这可能导致应用的响应时间过长。通过只对堆内存的一部分进行垃圾收集，可以减少每次垃圾收集时的暂停时间。

以上就是将Java堆内存分区的主要原因。通过这种方式，Java虚拟机可以更有效地管理内存，提高垃圾收集的性能，以及提供更稳定的应用响应时间。

3、调优

说说知道的几种主要的 JVM 参数

JVM 提供了大量的参数用于配置和调优，以下是一些主要的 JVM 参数：

1、 堆内存配置相关的参数：

2、 垃圾收集器相关的参数：

3、 性能调优和故障排查相关的参数：

以上只是 JVM 参数的一部分，JVM 提供了大量的参数用于调优和故障排查。在实际使用中，应根据应用的需求和运行环境来选择和配置这些参数。

JVM 调优的步骤

JVM调优主要分为以下几个步骤：

1、 确定目标：首先，需要确定调优的目标。是要减少系统的暂停时间（例如，减少垃圾收集的时间），还是提高系统的吞吐量（例如，每秒钟处理的任务数量），或者其他。不同的目标可能需要采取不同的调优策略。

2、 监控和分析：接下来，使用JVM提供的各种工具进行监控和分析，如VisualVM、jstat、jconsole等。这些工具可以帮助我们了解JVM的运行情况，例如堆内存的使用情况，垃圾收集的情况等。

3、 识别问题：分析监控数据，找出可能的性能瓶颈或问题，如频繁的垃圾收集，内存泄漏，CPU使用率过高等。

4、 调整参数：根据识别的问题，调整JVM的参数，如选择合适的垃圾收集器，调整堆内存的大小，新生代和老年代的比例等。这个过程可能需要多次尝试，以找到最优的参数配置。

5、 测试和验证：修改参数后，进行压力测试和性能测试，验证修改是否达到了预期的效果。如果效果不理想，可能需要返回步骤4，再次调整参数。

6、 持续监控：调优后，需要持续监控JVM的运行情况，因为随着应用的运行，系统的运行环境可能会变化，可能需要再次进行调优。

JVM调优是一个复杂的过程，需要深入理解JVM的工作原理和应用的运行情况。在进行调优时，一定要小心谨慎，避免因为不恰当的调优而导致系统性能下降。

一般什么时候考虑 JVM 调优呢？

JVM 调优通常在以下几种情况下考虑：

1、 内存溢出或内存泄漏：这是最常见的需要进行 JVM 调优的场景。当出现 OutOfMemoryError 错误，或者系统内存使用量持续上升，可能是内存溢出或内存泄漏问题。这时需要调整 JVM 参数，如堆内存大小，新生代和老年代的比例等，同时需要定位并修复内存泄漏问题。

2、 系统响应速度慢：如果系统的响应速度慢，可能是因为垃圾收集器频繁的 Full GC，导致系统暂停时间过长。这时可以考虑调整垃圾收集器设置或更换垃圾收集器，以减少 Full GC 的发生。

3、 CPU 使用率高：如果 CPU 使用率过高，可能是因为垃圾收集器的工作过于频繁。这时需要考虑调整 JVM 参数，以减轻垃圾收集的压力。

4、 系统吞吐量低：如果系统的吞吐量（每秒钟处理的任务数量）低，可能是因为 JVM 的配置不合理。这时需要根据系统的实际需求和运行环境，调整 JVM 参数，以提高系统的吞吐量。

5、 应用启动慢：如果应用的启动时间过长，可能是因为类加载器加载类的过程过慢，或者初始化堆内存大小设置过大，导致垃圾收集器在启动时进行大量的内存回收。这时可以调整类加载器的设置，或者调整堆内存的初始大小，以提高应用的启动速度。

在进行 JVM 调优时，一定要根据系统的实际需求和运行环境，结合 JVM 的性能监控和分析工具，进行合理的参数设置。同时，要注意调优是一个持续的过程，需要根据系统的运行情况不断进行调整。

强引用、软引用、弱引用、虚引用是什么？

在Java中，根据对象的可达性（可访问性）和回收性，引用被分为四种类型：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）。以下是四种引用类型的区别和示例：

1、 强引用（Strong Reference）：这是程序中最常见的普通对象引用，只要强引用还存在，垃圾收集器就永远不会回收掉被引用的对象。

Object obj = new Object();

2、 软引用（Soft Reference）：软引用关联的对象，在系统内存充足时不会被回收，只有在系统内存不足时才会被回收。软引用通常用于实现内存敏感的缓存。

Object obj = new Object();
SoftReference<Object> softRef = new SoftReference<>(obj);
obj = null; // 使 obj 成为软引用

3、 弱引用（Weak Reference）：无论当前内存空间足够与否，只要垃圾收集器线程扫描到弱引用关联的对象，就会回收这个对象。弱引用常常用于 Map 数据结构中的键（key），这样可以自动去除不再使用的键值对。

Object obj = new Object();
WeakReference<Object> weakRef = new WeakReference<>(obj);
obj = null; // 使 obj 成为弱引用

4、 虚引用（Phantom Reference）：虚引用关联的对象，有可能被垃圾收集器回收，也有可能不被回收，但是，我们不能通过虚引用访问到对象的任何属性或函数。所以，虚引用必须和引用队列（ReferenceQueue）联合使用。虚引用的主要用途是跟踪对象被垃圾回收器回收的活动，当某个对象被回收时，JVM 会把这个虚引用加入到与之关联的引用队列中。

ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
Object obj = new Object();
PhantomReference<Object> phantomRef = new PhantomReference<>(obj, refQueue);
obj = null; // 使 obj 成为虚引用

注意，上述示例中，通过 obj = null; 语句断开了强引用，使得对象只被软引用、弱引用或虚引用关联。否则，由于强引用的存在，对象将不会被垃圾收集器回收。

简单说说了解的类加载器，可以打破双亲委派么，怎么打破。

类加载器（ClassLoader）是 Java 运行时系统的一部分，负责在运行时查找和加载类文件到 JVM 中。在 Java 中，类加载器主要有以下几种：

1、 启动类加载器（Bootstrap ClassLoader）：是 JVM 自身的一部分，由 C++ 实现，负责加载 JAVA_HOME/lib 目录下的核心类库（如 rt.jar）。 2、 扩展类加载器（Extension ClassLoader）：由 Java 实现，负责加载 JAVA_HOME/lib/ext 目录下的类库。 3、 系统类加载器（System ClassLoader）：也称为应用类加载器，由 Java 实现，负责加载用户类路径（ClassPath）上的类库。

这三种类加载器之间的关系形成了一个称为 "双亲委派模型"（Parent Delegation Model）的层次结构。当一个类需要被加载时，系统类加载器会首先将这个任务委托给其父类加载器，也就是扩展类加载器；扩展类加载器再委托给启动类加载器。如果启动类加载器找不到这个类，就会返回给扩展类加载器；如果扩展类加载器也找不到，就会返回给系统类加载器。只有当父类加载器无法完成这个加载任务时，才由自身去加载。

双亲委派模型的主要目的是为了确保 Java 核心库的类型安全。这样，类即使在类路径中存在，也是由启动类加载器进行加载。这种方式保证了由不同类加载器最终加载该类都是同一份字节码。

但是，在某些情况下，我们可能需要打破双亲委派模型。例如，对于一些热替换（Hot Deployment）的功能，可能会需要自定义类加载器。为了实现这种功能，可以通过重写类加载器的 loadClass 方法来打破双亲委派模型。

@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    // 首先，检查该类是否已经被加载过
    Class<?> c = findLoadedClass(name);
    if (c == null) {
        try {
            // 尝试用自己的类加载器加载
            c = findClass(name);
        } catch (ClassNotFoundException e) {
            // 如果自己的类加载器加载失败，再委托给父类加载器
            c = super.loadClass(name, resolve);
        }
    }
    return c;
}

上述代码中，我们首先尝试用自己的类加载器加载类，如果失败，再委托给父类加载器。这样就打破了传统的双亲委派模型。

怎么打出线程栈信息

在 Java 中，可以通过几种方式打出线程栈信息：

1、 使用 jstack 命令：jstack 是 JDK 自带的一种命令行工具，可以用来生成当前时刻的线程快照。线程快照是线程活动的一种表示，它对于分析线程问题（如死锁）有很大的帮助。下面是 jstack 命令的基本用法：

jstack [pid]

其中，[pid] 是 Java 进程的 PID。可以通过 jps 命令找到 Java 进程的 PID。

2、 使用 kill -3 命令：在 Unix/linux 系统中，可以向 Java 进程发送 SIGQUIT 信号（即 kill -3）来生成线程快照。线程快照会被打印到标准错误流（stderr）或者由 -XX:OnOutOfMemoryError 参数指定的命令的输出中。

kill -3 [pid]

3、 在 Java 代码中使用 Thread.dumpStack() 方法：这个方法可以打印当前线程的栈信息到标准错误流（stderr）。

以下是一个简单的例子，演示如何使用 jstack 命令排查线程问题：

假设的 Java 应用在运行过程中出现了性能问题，怀疑是因为某个线程的 CPU 使用率过高。可以使用 top -H -p [pid] 命令找出 CPU 使用率最高的线程，然后使用 printf "%xn" [tid] 命令将线程的 TID（线程 ID）转换为十六进制的格式。然后，可以在 jstack [pid] 命令的输出中查找这个十六进制的 TID，找到对应的线程栈信息。通过分析线程栈信息，可以找出这个线程正在执行的代码，从而定位到问题的原因。

safepoint是什么？

"Safepoint"是Java HotSpot虚拟机中的一个术语。在执行一些全局性的操作（比如垃圾收集）时，Java虚拟机需要确保所有的线程都处于一种可知的、可控的状态，这种状态就是"Safepoint"。在Safepoint中，所有执行Java字节码的线程都会暂停，直到全局性的操作完成。

具体到HotSpot虚拟机，当它需要执行一些必须暂停所有线程的操作时（比如某种类型的垃圾收集），它会设置一个"Safepoint"。一旦设置了"Safepoint"，所有正在执行的线程会在下一个"Safepoint"检查点时暂停。线程可以在执行一些特定的字节码、调用方法、异常处理等地方设置检查点。一旦线程到达这些检查点，就会检查是否设置了"Safepoint"。如果设置了"Safepoint"，线程就会进入阻塞状态，等待全局性的操作完成。

需要注意的是，这个过程可能会导致应用的暂停，即所谓的"Stop-The-World"（STW）。STW会导致应用的响应时间增加，因此在设计和优化垃圾收集器时，通常会尽量减少STW的时间。

invokedynamic指令是干什么的？

invokedynamic是Java 7引入的一条新的字节码指令，这条指令为Java提供了动态类型（dynamic typing）的能力。在此之前，Java的方法调用都是静态类型的，也就是说，在编译时期就能确定方法的调用者和被调用的方法。invokedynamic指令打破了这个限制，允许在运行时动态地确定方法的调用者和被调用的方法。

invokedynamic指令的主要目的是为了支持在JVM上运行的动态类型语言，如Groovy、JRuby、Jython等。在这些语言中，方法的调用者和被调用的方法经常需要在运行时才能确定，这就需要动态类型的支持。

invokedynamic指令的工作方式与Java中其他的方法调用指令（如invokevirtual、invokeinterface等）有所不同。它不直接调用目标方法，而是通过所谓的调用点（call site）和方法句柄（method handle）。调用点是由一个引导方法（bootstrap method）初始化的，这个引导方法会返回一个方法句柄，这个方法句柄引用了真正要调用的方法。当invokedynamic指令执行时，它会通过调用点得到方法句柄，然后通过方法句柄调用目标方法。

这种设计提供了极大的灵活性，使得JVM可以有效地支持各种动态类型语言。此外，Java 8引入的Lambda表达式也使用了invokedynamic指令来实现。

栈帧都有哪些数据？

在Java虚拟机（JVM）中，每当一个方法被调用时，JVM都会为这个方法创建一个新的栈帧（Stack Frame）。每个栈帧都包含了一些用于支持方法调用和方法执行的数据。以下是栈帧中的主要组成部分：

1、 局部变量表（Local Variable Array）：这部分存储了方法的所有局部变量，包括方法的参数和方法内部定义的局部变量。局部变量表的大小在编译时确定，单位为slot，不会在方法执行过程中改变。

2、 操作数栈（Operand Stack）：这是一个后入先出（LIFO）的栈，用于存储方法执行过程中的临时数据。比如，在计算表达式的值时，会先把操作数压入操作数栈，然后执行操作，最后把结果压入操作数栈。

3、 动态链接（Dynamic Linking）：这部分用于支持方法调用过程中的动态链接。每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持动态链接。

4、 方法返回地址（Return Address）：当一个方法被调用时，需要在方法结束后返回到调用它的地方继续执行。这个返回地址就是方法调用者的PC计数器的值。

5、 附加信息（Additional Information）：可能还包含一些其他的信息，比如用于支持异常处理的信息等。

以上就是JVM中栈帧的主要组成部分。每个栈帧都对应一个正在执行的方法调用，这些栈帧在Java虚拟机栈中形成一个栈，用于支持Java程序的方法调用和方法执行。

Java的双亲委托机制是什么？

双亲委托模型（Parent Delegation Model）是Java类加载器（ClassLoader）在加载类时使用的一种模型。

在Java中，类加载器是用来加载类的工具。每一个类都是由一个类加载器加载的，而类加载器之间存在层级关系。在双亲委托模型中，如果一个类加载器收到了类加载的请求，它首先不会自己去加载，而是把这个请求委托给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器（Bootstrap ClassLoader）中。只有当父类加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载。

双亲委托模型的主要优点是：

1、 避免类的重复加载：由于所有的加载请求都交给了顶层，因此类在被加载时不会被其他的加载器再次加载，保证了Java对象的唯一性。

2、 保护了Java核心API的稳定性：Java核心库的类由启动类加载器加载，其他的类加载器不会加载这些类。这样就防止了恶意代码替换Java核心库，保护了Java核心API的稳定性。

双亲委托模型是Java类加载器的默认模型。然而，这并不是一个强制性的模型，如果有特殊需要，可以创建自定义的类加载器，打破这个模型。例如，Java的SPI（Service Provider Interface）机制，就需要打破双亲委托模型，由线程的上下文类加载器去加载服务提供者的实现类。

JIT是什么？

JIT（Just-In-Time）编译器是Java虚拟机的一部分，负责将字节码转换为可以直接在特定硬件和操作系统上运行的机器码。这种在运行时进行编译的技术被称为“即时编译”。

Java程序的运行过程一般分为两个阶段：解释执行和编译执行。Java源代码首先被编译成字节码，然后由JVM解释执行这些字节码。虽然字节码可以跨平台运行，但是解释执行的效率相对较低。

为了提高执行效率，JVM引入了JIT编译器。JIT编译器会监视运行的Java程序，找出经常执行（即“热点代码”）的部分，然后将这些字节码编译成机器码。这样，当这些代码再次执行时，JVM就可以直接执行机器码，从而大大提高了执行效率。

JIT编译器还会进行一些优化，比如方法内联、循环展开、常量折叠等，进一步提高执行效率。

因此，JIT编译器是JVM提高Java程序运行效率的一个重要工具。通过将字节码编译成机器码，并进行各种优化，JIT编译器使得Java程序的运行速度可以接近，甚至在某些情况下超过，编译型语言（如C++）的程序。

什么是方法内联？

方法内联（Method Inlining）是一种编译器优化技术，主要用于减少方法调用的开销。当一个方法被调用时，会有一些额外的运行时开销，比如建立新的栈帧、保存和恢复寄存器的值、跳转到方法的入口点等。通过方法内联，编译器可以将方法的体直接插入到调用它的地方，从而避免这些开销。

例如，假设我们有如下的代码：

void methodA() {
    methodB();
}

void methodB() {
    // do something
}

通过方法内联，上述代码可以被优化为：

void methodA() {
    // do something
}

Java的即时编译器（JIT）在运行时会进行方法内联。JIT会根据运行时的性能数据（比如方法的调用频率）来决定哪些方法需要内联。通常来说，频繁调用的小方法是内联的好候选者。

需要注意的是，方法内联并不总是提高性能。如果一个方法很大，或者被内联的方法的数量过多，可能会导致编译后的代码太大，从而影响指令缓存的效率。因此，Java的JIT编译器会使用一些启发式方法来决定何时以及如何进行方法内联。

Java虚拟机调用字节码指令有哪些？

Java虚拟机（JVM）使用的是基于栈的架构，其核心是一组字节码指令集。字节码是Java编译器编译Java源代码后的产物，每一条字节码指令都对应一个操作码（opcode）。下面是一些常见的字节码指令分类：

1、 加载和存储指令：这类指令用于在局部变量表和操作数栈之间移动数据。例如，iload、aload、istore、astore等。

2、 算术指令：这类指令用于执行基本的算术运算，如加法、减法、乘法、除法等。例如，iadd、isub、imul、idiv等。

3、 类型转换指令：这类指令用于将两种不同的数值类型进行相互转换。例如，i2l、i2d、l2i等。

4、 对象创建与访问指令：这类指令用于创建对象、数组，以及访问对象的字段和数组的元素。例如，new、getfield、putfield、getstatic、putstatic、newarray等。

5、 操作数栈管理指令：这类指令用于直接操作操作数栈，包括将常量压入栈、弹出栈顶元素、复制栈顶元素等。例如，iconst、pop、dup等。

6、 控制转移指令：这类指令用于控制流程的转移，包括条件和无条件的跳转、方法调用和返回等。例如，ifeq、ifne、goto、invokevirtual、invokestatic、invokespecial、invokeinterface、invokedynamic、return等。

7、 异常处理指令：这类指令用于异常的抛出。例如，athrow。

8、 同步指令：这类指令用于多线程同步。例如，monitorenter、monitorexit。

每种指令都有自己的操作语义，而且很多指令都有自己的操作数，这些操作数提供了额外的信息，比如要加载或存储的局部变量的索引，要跳转的目标地址等。这个字节码指令集使得Java具有跨平台的能力，因为JVM可以在任何支持的平台上解释执行这些字节码。

Java当中的常量池

在Java中，常量池（Constant Pool）是Java虚拟机（JVM）的一部分，主要用于存储常量信息。常量池的主要任务是为Java类提供变量和方法的引用。每个加载的类（包括类和接口等）以及每个Java方法都有一个常量池。

常量池主要包括以下几种常量：

1、 类和接口常量：包含了对一个类或接口的全限定名的引用。

2、 字段引用：包含了字段的类、名称和类型的引用。

3、 方法引用：包含了方法的类、方法名称和方法描述符的引用。

4、 字符串常量：Java字符串直接量就是存储在常量池中的。

5、 数值常量：包括整数（Integer）、浮点数（Float）、长整型（Long）和双精度浮点型（Double）。

6、 方法类型和方法句柄：这是Java 7引入的，主要是为了支持动态类型语言。

在Java 7及之前的版本中，常量池是存储在方法区中的，而在Java 8及以后的版本中，由于方法区被移除，常量池被移动到了元空间（Metaspace）中。

常量池有以下几个特点：

声明：本站部分内容来自互联网,如有版权侵犯或其他问题请与我们联系，我们将立即删除或处理。
▍相关推荐
更多资讯 >>>
Copyright @ 简易百科 V 2.0 京ICP备14042104号