Java面试题2.0--jvm

逃离我推掉我的手 2021-09-24 08:40 340阅读 0赞

## 欢迎关注[《Java面试题2.0》][Java_2.0]合集发布页，持续更新中！ ##

**程序计数器（Program Counter Register）**

程序计数器是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器。

由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，一个处理器都只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都有一个独立的程序计数器，各个线程之间计数器互不影响，独立存储。称之为“线程私有”的内存。程序计数器内存区域是虚拟机中唯一没有规定OutOfMemoryError情况的区域。

**堆、栈、方法区概念区别**

**Java堆**

堆内存用于存放由new创建的对象和数组。

**堆内存中分配两个区：新生代、老年代**

**新生代：eden、s0、s1; s0和s1的大小一样**

**刚创建，会存放在eden区域里面**

**新生代：刚创建对象，先存放在新生代**

**老年代：如果对象在频繁的使用，对象放入老年代**

**垃圾回收机制主要发生在新生代**

**Java方法区**

**永久区，存放static关键字修饰的内容、常量信息以及类信息。**

**文件被加载的时候，就会被初始化，所有线程会被共享。**

Java方法区和堆一样，方法区是一块所有线程共享的内存区域，他保存系统的类信息。

比如类的字段、方法、常量池等。方法区的大小决定系统可以保存多少个类。如果系统

定义太多的类，导致方法区溢出。虚拟机同样会抛出内存溢出的错误。方法区可以理解

为永久区。

**Java栈**

**定义基本局部变量，栈代码运行完毕，自动释放内存。**

**每个线程私有，互不共享，栈不会产生线程安全问题。**

Java栈是一块线程私有的空间，一个栈，一般由三部分组成:局部变量表、操作数据栈和帧数据区

局部变量表：用于报错函数的参数及局部变量

操作数栈：主要保存计算过程的中间结果，同时作为计算过程中的变量临时的存储空间。

帧数据区:除了局部变量表和操作数据栈以外，栈还需要一些数据来支持常量池的解析，这里帧数据区保存着

访问常量池的指针，方便计程序访问常量池，另外当函数返回或出现异常时卖虚拟机子必须有一个异常处理表，方便发送异常

的时候找到异常的代码，因此异常处理表也是帧数据区的一部分。

**堆的参数配置**

\-XX:+PrintGC      每次触发GC的时候打印相关日志

\-XX:+UseSerialGC      串行回收

\-XX:+PrintGCDetails  更详细的GC日志

\-Xms               堆初始值

\-Xmx               堆最大可用值

\-Xmn               新生代堆最大可用值

\-XX:SurvivorRatio     用来设置新生代中eden空间和from/to空间的比例.

含以-XX:SurvivorRatio=eden/from=den/to

总结:在实际工作中，我们可以直接将初始的堆大小与最大堆大小相等，

这样的好处是可以减少程序运行时垃圾回收次数，从而提高效率。

**设置新生代与老年代优化参数**

\-Xmn    新生代大小，一般设为整个堆的1/3到1/4左右

\-XX:SurvivorRatio    设置新生代中eden区和from/to空间的比例关系n/1

\-Xms20m -Xmx20m -XX:SurvivorRatio=2 -XX:+PrintGCDetails -XX:+UseSerialGC

\-XX:NewRatio=2

总结:不同的堆分布情况，对系统执行会产生一定的影响，在实际工作中，

应该根据系统的特点做出合理的配置，基本策略：尽可能将对象预留在新生代，

减少老年代的GC次数。

除了可以设置新生代的绝对大小(-Xmn),可以使用(-XX:NewRatio)设置新生代和老年

代的比例:-XX:NewRatio=老年代/新生代

**内存溢出解决办法**

**设置堆内存大小**

错误原因: java.lang.OutOfMemoryError: Java heap space 堆内存溢出

解决办法:设置堆内存大小 -Xms1m –Xmx10m -XX:+HeapDumpOnOutOfMemoryError

**设置栈内存大小**

错误原因: java.lang.StackOverflowError  栈内存溢出

栈溢出 产生于递归调用，循环遍历是不会的，但是循环方法里面产生递归调用， 也会发生栈溢出。

解决办法:设置线程最大调用深度

\-Xss5m 设置最大调用深度

Tomcat内存溢出在catalina.sh 修改JVM堆内存大小

JAVA\_OPTS="-server -Xms800m -Xmx800m -XX:PermSize=256m -XX:MaxPermSize=512m -XX:MaxNewSize=512m

**JVM参数调优总结**

在JVM启动参数中，可以设置跟内存、垃圾回收相关的一些参数设置，默认情况不做任何设置JVM会工作的很好，但对一些配置很好的Server和具体的应用必须仔细调优才能获得最佳性能。通过设置我们希望达到一些目标：

GC的时间足够的小

GC的次数足够的少

发生Full GC(新生代和老年代)的周期足够的长

前两个目前是相悖的，要想GC时间小必须要一个更小的堆，要保证GC次数足够少，必须保证一个更大的堆，我们只能取其平衡。

（1）针对JVM堆的设置，一般可以通过-Xms -Xmx限定其最小、最大值，为了防止垃圾收集器在最小、最大之间收缩堆而产生额外的时间，我们通常把最大、最小设置为相同的值

（2）年轻代和年老代将根据默认的比例（1：2）分配堆内存，可以通过调整二者之间的比率NewRadio来调整二者之间的大小，也可以针对回收代，比如年轻代，通过 -XX:newSize -XX:MaxNewSize来设置其绝对大小。同样，为了防止年轻代的堆收缩，我们通常会把-XX:newSize -XX:MaxNewSize设置为同样大小

（3）年轻代和年老代设置多大才算合理？这个我问题毫无疑问是没有答案的，否则也就不会有调优。我们观察一下二者大小变化有哪些影响

更大的年轻代必然导致更小的年老代，大的年轻代会延长普通GC的周期，但会增加每次GC的时间；小的年老代会导致更频繁的Full GC

更小的年轻代必然导致更大年老代，小的年轻代会导致普通GC很频繁，但每次的GC时间会更短；大的年老代会减少Full GC的频率

如何选择应该依赖应用程序对象生命周期的分布情况：如果应用存在大量的临时对象，应该选择更大的年轻代；如果存在相对较多的持久对象，年老代应该适当增大。但很多应用都没有这样明显的特性，在抉择时应该根据以下两点：（A）本着Full GC尽量少的原则，让年老代尽量缓存常用对象，JVM的默认比例1：2也是这个道理 （B）通过观察应用一段时间，看其他在峰值时年老代会占多少内存，在不影响Full GC的前提下，根据实际情况加大年轻代，比如可以把比例控制在1：1。但应该给年老代至少预留1/3的增长空间

不可达的对象并不会马上就会被直接回收，而是至少要经过两次标记的过程。

**finalize作用**

Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。

**内存泄露**

内存泄漏的定义：对象已经没有被应用程序使用，但是垃圾回收器没办法移除它们，因为还在被引用着。

**如何防止内存泄露**

下面是几条容易上手的建议，来帮助你防止内存泄漏的发生。

1、特别注意一些像HashMap、ArrayList的集合对象，它们经常会引发内存泄漏。当它们被声明为static时，它们的生命周期就会和应用程序一样长。

2、特别注意事件监听和回调函数。当一个监听器在使用的时候被注册，但不再使用之后却未被反注册。

3、“如果一个类自己管理内存，那开发人员就得小心内存泄漏问题了。” 通常一些成员变量引用其他对象，初始化的时候需要置空。

**内存溢出与内存泄漏的区别**

内存泄露：指程序中动态分配内存给一些临时对象，但是对象不会被GC所回收，它始终占用内存。即被分配的对象可达但已无用。

内存溢出：指程序运行过程中无法申请到足够的内存而导致的一种错误。内存溢出通常发生于OLD段或Perm段垃圾回收后，仍然无内存空间容纳新的Java对象的情况(OOM)。

**Minor GC和Full GC区别**

概念：

新生代 GC（Minor GC）：指发生在新生代的垃圾收集动作，因为 Java 对象大多都具备朝生夕灭的特性，所以 Minor GC 非常频繁，一般回收速度也比较快。

老年代 GC（Major GC  / Full GC）：指发生在老年代的 GC，出现了 Major GC，经常会伴随至少一次的 Minor GC（但非绝对的，在 ParallelScavenge 收集器的收集策略里

就有直接进行 Major GC 的策略选择过程） 。MajorGC 的速度一般会比 Minor GC 慢 10倍以上。

Minor GC触发机制：

当年轻代满时就会触发Minor GC，这里的年轻代满指的是Eden代满，Survivor满不会引发GCFull GC触发机制：

当年老代满时会引发Full GC，Full GC将会同时回收年轻代、年老代，当永久代满时也会引发Full GC，会导致Class、Method元信息的卸载

**JVM的永久代中会发生垃圾回收么？**

垃圾回收不会发生在永久代，如果永久代满了或者是超过了临界值，会触发完全垃圾回收(Full GC)。如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回收的。这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。请参考下Java8：从永久代到元数据区

**如何判断对象是否存活**

1、引用计数法：引用计数法就是如果一个对象没有被任何引用指向，则可视之为垃圾。这种方法的缺点就是不能检测到环的存在。

首先需要声明，至少主流的Java虚拟机里面都没有选用引用计数算法来管理内存。

2、根搜索算法：根搜索算法的基本思路就是通过一系列名为”GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链(Reference Chain)，当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。

如何选取GCRoots对象呢？在Java语言中，可以作为GCRoots的对象包括下面几种：

(1). 虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。

(2). 方法区中的类静态属性引用的对象。

(3). 方法区中常量引用的对象。

(4). 本地方法栈中JNI(Native方法)引用的对象。

**垃圾回收算法：**

**引用计数法**

**1.1概述**

给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器都为0的对象就是不再被使用的，垃圾收集器将回收该对象使用的内存。

**1.2优缺点**

优点：

引用计数收集器可以很快的执行，交织在程序运行中。对程序需要不被长时间打断的实时环境比较有利。

缺点：

无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0.而且每次加减非常浪费内存。

**复制算法**

S0和s1将可用内存按容量分成大小相等的两块，每次只使用其中一块，当这块内存使用完了，就将还存活的对象复制到另一块内存上去，然后把使用过的内存空间一次清理掉。这样使得每次都是对其中一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。

复制算法的缺点显而易见，可使用的内存降为原来一半。

复制算法用于在新生代垃圾回收。因为新生代中的对象一般都是朝生夕死的，存活对象的数量并不多，这样使用coping算法进行拷贝时效率比较高。

优点:在存活对象不多的情况下，性能高，能解决内存碎片和java垃圾回收算法之-标记清除 中导致的引用更新问题。

缺点: 会造成一部分的内存浪费。不过可以根据实际情况，将内存块大小比例适当调整；如果存活对象的数量比较大，coping的性能会变得很差。

**标记清除算法**

该算法有两个阶段。

1. 标记阶段：找到所有可访问的对象，做个标记

2. 清除阶段：遍历堆，把未被标记的对象回收

**应用场景**

该算法一般应用于老年代,因为老年代的对象生命周期比较长。

**标记清除算法的优点和缺点**

1. 优点

\- 是可以解决循环引用的问题

\- 必要时才回收(内存不足时)

2. 缺点：

\- 回收时，应用需要挂起，也就是stop the world。

\- 标记和清除的效率不高，尤其是要扫描的对象比较多的时候

\- 会造成内存碎片(会导致明明有内存空间,但是由于不连续,申请稍微大一些的对象无法做到)

**标记-压缩算法**

标记压缩法在标记清除基础之上做了优化，把存活的对象压缩到内存一端,而后进行垃圾清理。(java中老年代使用的就是标记压缩法)

**标记清除、标记压缩都会发生在老年代，因为它只判断一次，如果没有引用就直接回收掉，很频繁。**

优点:解决内存碎片问题，缺点压缩阶段，由于移动了可用对象，需要去更新引用。

**分代收集算法**

根据内存中对象的存活周期不同，将内存划分为几块，java的虚拟机中一般把内存划分为新生代和年老代，当新创建对象时一般在新生代中分配内存空间，当新生代垃圾收集器回收几次之后仍然存活的对象会被移动到年老代内存中，当大对象在新生代中无法找到足够的连续内存时也直接在年老代中创建。

**对于新生代和老年代来说,新生代回收频率很高,但是每次回收耗时很短,而老年代回收频率较低,但是耗时会相对较长,所以应该尽量减少老年代的GC.**

**就是根据分代，采用不同的算法**

为什么老年代使用标记压缩、新生代使用复制算法，

**垃圾回收时的停顿现象**

垃圾回收的任务是识别和回收垃圾对象进行内存清理，为了让垃圾回收器可以更高效的执行，大部分情况下，会要求系统进如一个停顿的状态。停顿的目的是为了终止所有的应用线程，只有这样的系统才不会有新垃圾的产生。同时停顿保证了系统状态在某一个瞬间的一致性，也有利于更好的标记垃圾对象。因此在垃圾回收时，都会产生应用程序的停顿。

**什么是Java垃圾回收器**

Java垃圾回收器是Java虚拟机(JVM)的三个重要模块(另外两个是解释器和多线程机制)之一，为应用程序提供内存的自动分配(Memory Allocation)、自动回收(Garbage Collect)功能，这两个操作都发生在Java堆上(一段内存快)。某一个时点，一个对象如果有一个以上的引用(Rreference)指向它，那么该对象就为活着的(Live)，否则死亡(Dead)，视为垃圾，可被垃圾回收器回收再利用。垃圾回收操作需要消耗CPU、线程、时间等资源，所以容易理解的是垃圾回收操作不是实时的发生(对象死亡马上释放)，当内存消耗完或者是达到某一个指标(Threshold,使用内存占总内存的比列，比如0.75)时，触发垃圾回收操作。有一个对象死亡的例外，java.lang.Thread类型的对象即使没有引用，只要线程还在运行，就不会被回收。

**串行回收器(Serial Collector)**

单线程执行回收操作，回收期间暂停所有应用线程的执行，client模式下的默认回收器，通过-XX:+UseSerialGC命令行可选项强制指定。参数可以设置使用新生代串行和老年代串行回收器。

**并行回收器(ParNew回收器)**

并行回收器在串行回收器基础上做了改进，他可以使用多个线程同时进行垃

圾回收，对于计算能力强的计算机而言，可以有效的缩短垃圾回收所需的尖

际时间。

ParNew回收器是一个工作在新生代的垃圾收集器，他只是简单的将串行回收

器多线程快他的回收策略和算法和串行回收器一样。

**并行回收集器(ParallelGC)**

老年代ParallelOldGC回收器也是一种多线程的回收器，和新生代的

ParallelGC回收器一样，也是一种关往吞吐量的回收器，他使用了标记压缩

算法进行实现。

**并CMS(并发GC)收集器**

CMS(Concurrent Mark Sweep)收集器是一种以获取最短回收停顿时间为目标的收集器。CMS收集器是基于“标记-清除”算法实现的，

**G1回收器**

G1回收器(Garbage-First)实在\]dk1.7中提出的垃圾回收器，从长期目标来看是为了取

代CMS回收器，G1回收器拥有独特的垃圾回收策略，G1属于分代垃圾回收器，区分

新生代和老年代，依然有eden和from/to区,它并不要求整个eden区或者新生代、老

年代的空间都连续，它使用了分区算法

**调优总结**

初始堆值和最大堆内存内存越大，吞吐量就越高。

最好使用并行收集器,因为并行手机器速度比串行吞吐量高，速度快。

设置堆内存新生代的比例和老年代的比例最好为1:2或者1:3。

减少GC对老年代的回收。

**类加载机制**

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口，这个过程需要类加载器参与。

当系统运行时，类加载器将.class文件的二进制数据从外部存储器（如光盘，硬盘）调入内存中，CPU再从内存中读取指令和数据进行运算，并将运算结果存入内存中。

**连接过程**

将java类的二进制代码合并到JVM的运行状态之中的过程

验证：确保加载的类信息符合JVM规范，没有安全方面的问题

准备：正式为类变量（static变量）分配内存并设置类变量初始值的阶段，这些内存都将在方法区中进行分配

解析：虚拟机常量池的符号引用替换为字节引用过程

**类加载器种类**

启动（Bootstrap）类加载器：负责将 Java\_Home/lib下面的类库加载到内存中（比如rt.jar）。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。

标准扩展（Extension）类加载器：是由 Sun 的 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将Java\_Home /lib/ext或者由系统变量 java.ext.dir指定位置中的类库加载到内存中。开发者可以直接使用标准扩展类加载器。

应用程序（Application）类加载器：是由 Sun 的 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。它负责将系统类路径（CLASSPATH）中指定的类库加载到内存中。开发者可以直接使用系统类加载器。由于这个类加载器是ClassLoader中的getSystemClassLoader()方法的返回值，因此一般称为系统（System）加载器。

**双亲委派模式**

某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。

**双亲委派模式优势**

采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。其次是考虑到安全因素，java核心api中定义类型不会被随意替换。

**实现热部署的三个步骤：**

1、销毁该自定义ClassLoader

2、更新class类文件

3、创建新的ClassLoader去加载更新后的class类文件。

参考资料

[https://blog.csdn.net/a347911/article/details/53515448][https_blog.csdn.net_a347911_article_details_53515448]

[https://blog.csdn.net/antony9118/article/details/51375662][https_blog.csdn.net_antony9118_article_details_51375662]

[https://blog.csdn.net/zhangliangzi/article/details/51338291][https_blog.csdn.net_zhangliangzi_article_details_51338291]

[https://blog.csdn.net/zhangliangzi/article/details/51319033][https_blog.csdn.net_zhangliangzi_article_details_51319033]

[Java_2.0]: https://blog.csdn.net/pzq915981048/article/details/106057220
[https_blog.csdn.net_a347911_article_details_53515448]: https://blog.csdn.net/a347911/article/details/53515448
[https_blog.csdn.net_antony9118_article_details_51375662]: https://blog.csdn.net/antony9118/article/details/51375662
[https_blog.csdn.net_zhangliangzi_article_details_51338291]: https://blog.csdn.net/zhangliangzi/article/details/51338291
[https_blog.csdn.net_zhangliangzi_article_details_51319033]: https://blog.csdn.net/zhangliangzi/article/details/51319033