30道JVM综合面试题详解含答案（值得珍藏）

本文主要是介绍30道JVM综合面试题详解含答案（值得珍藏），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1. 描述一下JVM加载Class文件的原理机制?

Java中的所有类，都需要由类加载器装载到JVM中才能运行。类加载器本身也是一个类，而它的工作就是把class文件从硬盘读取到内存中。在写程序的时候，我们几乎不需要关心类的加载，因为这些都是隐式装载的，除非我们有特殊的用法，像是反射，就需要显式的加载所需要的类。

Java类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类(像是基类)完全加载到jvm中，至于其他类，则在需要的时候才加载。这当然就是为了节省内存开销。

Java的类加载器有三个，对应Java的三种类：
在这里插入图片描述

三个加载器各自完成自己的工作，但它们是如何协调工作呢？哪一个类该由哪个类加载器完成呢？为了解决这个问题，Java采用了委托模型机制。

委托模型机制的工作原理很简单：当类加载器需要加载类的时候，先请示其Parent(即上一层加载器)在其搜索路径载入，如果找不到，才在自己的搜索路径搜索该类。这样的顺序其实就是加载器层次上自顶而下的搜索，因为加载器必须保证基础类的加载。之所以是这种机制，还有一个安全上的考虑：如果某人将一个恶意的基础类加载到jvm，委托模型机制会搜索其父类加载器，显然是不可能找到的，自然就不会将该类加载进来。我们可以通过这样的代码来获取类加载器：

ClassLoader oader = ClassName.class.getClassLoader();
ClassLoader ParentLoader = loader.getParent();

注意一个很重要的问题，就是Java在逻辑上并不存在BootstrapKLoader的实体！因为它是用C++编写的，所以打印其内容将会得到null。

前面是对类加载器的简单介绍，它的原理机制非常简单，就是下面几个步骤：

装载：查找和导入class文件;
连接

(1)检查：检查载入的class文件数据的正确性:

(2)准备：为类的静态变量分配存储空间;

(3)解析：将符号引用转换成直接引用(这一步是可选的)

初始化：初始化静态变量，静态代码块。这样的过程在程序调用类的静态成员的时候开始执行，所以静态方法main()才会成为一般程序的入口方法。类的构造器也会引发该动作。

2. 什么是类加载器？

类加载器是一个用来加载类文件的类。Java源代码通过javac编译器编译成类文件。然后JVM来执行类文件中的字节码来执行程序。类加载器负责加载文件系统、网络或其他来源的类文件。

3. 类加载器有哪些？

有三种默认使用的类加载器：Bootstrap类加载器、Extension类加载器和Application类加载器。每种类加载器都有设定好从哪里加载类。

Bootstrap类加载器负责加载rt.jar中的JDK类文件，它是所有类加载器的父加载器。Bootstrap类加载器没有任何父类加载器，如果你调用String.class.getClassLoader()，会返回null，任何基于此的代码会抛出NullPointerException异常。Bootstrap加载器被称为初始类加载器。

而Extension将加载类的请求先委托给它的父加载器，也就是Bootstrap，如果没有成功加载的话，再从jre/lib/ext目录下或者java.ext.dirs系统属性定义的目录下加载类。Extension加载器由sun.misc.LauncherͅExtClassLoader实现。

第三种默认的加载器就是Application类加载器了。它负责从classpath环境变量中加载某些应用相关的类，classpath环境变量通常由-classpath或-cp命令行选项来定义，或者是JAR中的Manifest的classpath属性。Application类加载器是Extension类加载器的子加载器。通过sun.misc.LauncherͅAppClassLoader实现。

4. 什么是双亲委派模型(Parent-Delegation Model)？

JVM中加载类机制采用的是双亲委派模型，顾名思义，在该模型中，子类加载器收到的加载请求，不会先去处理，而是先把请求委派给父类加载器处理，当父类加载器处理不了时再返回给子类加载器加载；

5. 为什么使用双亲委派模型？

因为安全。使用双亲委派模型来组织类加载器间的关系，能够使类的加载也具有层次关系，这样能够保证核心基础的Java类会被根加载器加载，而不会去加载用户自定义的和基础类库相同名字的类，从而保证系统的有序、安全。

6. Java内存分配基本概念

每运行一个java程序会产生一个java进程，每个java进程可能包含一个或者多个线程，每一个Java进程对应唯一一个JVM实例，每一个JVM实例唯一对应一个堆，每一个线程有一个自己私有的栈。进程所创建的所有类的实例（也就是对象）或数组（指的是数组的本身，不是引用）都放在堆中,并由该进程所有的线程共享。Java中分配堆内存是自动初始化的，即为一个对象分配内存的时候，会初始化这个对象中变量。虽然Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在栈中分配,也就是说在建立一个对象时在堆和栈中都分配内存，在堆中分配的内存实际存放这个被创建的对象的本身，而在栈中分配的内存只是存放指向这个堆对象的引用而已。局部变量 new 出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待GC回收。

具体的概念：JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method，也叫静态区)：

堆区：存储的全部是对象，每个对象都包含一个与之对应的class的信息(class的目的是得到操作指令) ；jvm只有一个堆区(heap)，且被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身和数组本身；

栈区：每个线程包含一个栈区，栈中只保存基础数据类型本身和自定义对象的引用；每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问；栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)；

方法区（静态区）:
被所有的线程共享，方法区包含所有的class（class是指类的原始代码，要创建一个类的对象，首先要把该类的代码加载到方法区中，并且初始化）和static变量。方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。

7. 在Java语言里堆(heap)和栈(stack)里的区别

栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享（详见下面的介绍）。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

Java中的2种数据类型：

一种是基本类型(primitive types), 共有8类，即int, short, long, byte, ϐloat, double, boolean,char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里
面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。栈有一个很重要的特性:存在栈中的数据可以共享。假设我们同时定义: int a = 3; int b =3; 编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，如果没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与 b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。

对比	JVM堆	JVM栈
物理地址	堆的物理地址分配对对象是不连续的。因此性能慢些。在GC的时候也要考虑到不连续的分配，所以有各种算法。比如，标记-消除，复制，标记-压缩，分代（即新生代使用复制算法，老年代使用标记——压缩）	栈使用的是数据结构中的栈，先进后出的原则，物理地址分配是连续的。所以性能快。
内存分别	堆因为是不连续的，所以分配的内存是在运行期确认的，因此大小不固定。一般堆大小远远大于栈。	栈是连续的，所以分配的内存大小要在编译期就确认，大小是固定的。
存放的内容	堆存放的是对象的实例和数组。因此该区更关注的是数据的存储	栈存放：局部变量，操作数栈，返回结果。该区更关注的是程序方法的执行。
程序的可见度	堆对于整个应用程序都是共享、可见的。	栈只对于线程是可见的。所以也是线程私有。他的生命周期和线程相同。

8.Java堆的结构是什么样子的？

JVM的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存。它在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就是垃圾收集器回收。

堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的，不会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收掉的对象。一直到垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间。

永久代是用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate 等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类>

永久代中一般包含：

类的方法(字节码…)
类名(Sring对象)
.class文件读到的常量信息
class对象相关的对象列表和类型列表 (e.g., 方法对象的array).
JVM创建的内部对象
JIT编译器优化用的信息

虚拟机中的共划分为三个代：

年轻代（Young Generation）、年老代（Old Generation）和持久代（PermanentGeneration）。其中持久代主要存放的是Java类的类信息，与垃圾收集要收集的Java对象关系不大。年轻代和年老代的划分是对垃圾收集影响比较大的。

年轻代:

所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。年轻代分三个区。一个Eden区，两个 Survivor区(一般而言)。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个 Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。同时，根据程序需要，Survivor区是可以配置为多个的（多于两个），这样可以增加对象在年轻代中的存在时间，减少被放到年老代的可能。

年老代:

在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。

持久代:

用于存放静态文件，如今Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate 等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=进行设置。

注意：

JDK1.8中，永久代已经从java堆中移除，String直接存放在堆中，类的元数据存储在meta space中，meta space占用外部内存，不占用堆内存。可以说，在java8的新版本中，持久代已经更名为了元空间（meta space）。

9. 说说运行时数据区域

运行时数据区域包括方法区、虚拟机栈、本地方法栈、堆、程序计数器。其中方法区和堆是所有线程共享的数据区，其他的是线程隔离的数据区。

在这里插入图片描述

9.1 程序计数器

程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器，确定下一条需要执行的字节码指令。java的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何确定的一个时刻，一个处理器只会执行一条线程中的指令。为了线程切换之后能恢复到正确的执行位置，每个线程都需要有一个独立的程序计数器，各个线程之间的计数器互不影响。如果线程正在执行的是一个java方法，则计数器记录
的是正在执行的虚拟机字节码指令的地址，如果正在执行的是native方法，则计数器值为空。

9.2 java虚拟机栈

在这里插入图片描述

java虚拟机栈也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是java方法执行的内存模型：每个方法被执行的时候都会创建一个栈帧用于存在局部变量表、操作栈、动态链接、方法出口等信息。通过所说的栈是局部变量表，即与对象内存分配关系最密切的内存区域。局部变量表的内存空间在编译期间完成分配，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是确定的，在运行期不会改变。

java虚拟机栈有两种异常：如果线程请求的栈深度大于虚拟机所允许的深度，则抛弃StackOverϐlowError异常；如果虚拟机栈可以动态扩展的，当扩展时无法申请到足够的内存时会抛出OutOfMemoryError异常。

9.3 本地方法栈

本地方法栈与虚拟机栈所发挥的作用是相似的，区别在于虚拟机栈为虚拟机执行java方法的服务，本地方法栈则是为虚拟机使用到native方法服务。

9.4 java堆

java堆是虚拟机所管理的内存中最大的一块，是虚拟机启动是创建的能被所有线程共享的一块内存区域。java堆的唯一目的就是存放对象实例，几乎所有的对象实例和数组都在这里分配内存（随着JTI编译器的发展，在栈上也有可能分配）。java堆是垃圾收集器管理的主要区域，在物理上可以使不连续的内存空间，但在逻辑上是联系的。如果再堆中没有内存完成实例的分配，并且堆也无法在扩展的时候，将会抛出OutOfMemoryError异常。

9.5 方法区

方法区也是线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。这块区域很少进行垃圾回收，甚至可以不实现垃圾收集，主要是针对常量池的回收和对类型的卸载。当方法区无法分配内存的时候，将抛出OutOfMemoryError异常。

Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息就是常量池，用于存放编译期的各种字面量和符号引用。并非预置入 Class文件中的常量才能进入常量池，运行期间也可能将新的常量放入池中，开发中用的比较多的是String类的intern()方法。

10. Java中会存在内存泄漏吗，简述一下？

理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收，因此也会导致内存泄露的发生。例如Hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（ϐlush）一级缓存就可能导致内存泄露。

11. Java类加载过程？

在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备、解析。

装载：查找和导入类或接口的二进制数据；

链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的；

校验：检查导入类或接口的二进制数据的正确性；

准备：给类的静态变量分配并初始化存储空间；

解析：将符号引用转成直接引用；

初始化：激活类的静态变量,初始化Java代码和静态Java代码块

12. 什么是GC?为什么要有GC？

GC是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc()或Runtime.getRuntime().gc()，但JVM可以屏蔽掉显示的垃圾回收调用。

垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

在Java诞生初期，垃圾回收是Java最大的亮点之一，因为服务器端的编程需要有效的防止内存泄露问题，然而时过境迁，如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS的系统比Android系统有更好的用户体验，其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。

采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域，在垃圾收集过程中，可能会将对象移动到不同区域：

伊甸园（Eden）：这是对象最初诞生的区域，并且对大多数对象来说，这里是它们唯一存在过的区域。

幸存者乐园（Survivor）：从伊甸园幸存下来的对象会被挪到这里。

终身颐养园（Tenured）：这是足够老的幸存对象的归宿。年轻代收集（Minor-GC）过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时，就会触发一次完全收集（Major-GC），这里可能还会牵扯到压缩，以便为大对象腾出足够的空间。

与垃圾回收相关的JVM参数：

-Xms / -Xmx —堆的初始大小 / 堆的最大大小

-Xmn — 堆中年轻代的大小

Java有了GC，就不需要程序员去人工释放内存空间。当Java虚拟机发觉内存资源紧张的时候，就会自动地去清理无用变量所占用的内存空间。当然，如果需要，程序员可以在Java程序中显式地使用System.gc()来强制进行一次立即的内存清理。

因为显式声明是做堆内存全扫描，也就是 Full GC，是需要停止所有的活动的（Stop The World Collection），你的应用能承受这个吗？而其显示调用System.gc()只是给虚拟机一个建议，不一定会执行，因为System.gc()在一个优先级很低的线程中执行。

13. 简述一下Java垃圾回收机制？

什么是垃圾回收机制：

在系统运行过程中，会产生一些无用的对象，这些对象占据着一定的内存，如果不对这些对象清理回收无用对象的内存，可能会导致内存的耗尽，所以垃圾回收机制回收的是内存。同时GC回收的是堆区和方法区的内存。

JVM回收特点：

(stop-the-world)当要进行垃圾回收时候，不管何种GC算法，除了垃圾回收的线程之外其他任何线程都将停止运行。被中断的任务将会在垃圾回收完成后恢复进行。GC不同算法或是GC调优就是减少stop-the-world的时间。当在垃圾回收时候不暂停所有的程序，在垃圾回收时候有new一个新的对象B，此时对象A是可达B的，但是没有来及标记就把B当成无用的对象给清理掉了，这就会导致程序的运行会出现错误。

如何判断哪些对象需要回收呢：

引用计数算法（java中不是使用此方法）：

每个对象中添加一个引用计数器，当有别人引用它的时候，计数器就会加1，当别人不引用它的时候，计数器就会减1，当计数器为0的时候对象就可以当成垃圾。算法简单，但是最大问题就是在循环引用的时候不能够正确把对象当成垃圾。
根搜索方法（这是后面垃圾搜集算法的基础）：

这是JVM一般使用的算法，设立若干了根对象，当上述若干个跟对象对某一个对象都不可达的时候，这个对象就是无用的对象。对象所占的内存可以回收。根搜索算法的基础上，现代虚拟机的实现当中，垃圾搜集的算法主要有三种，分别是标记-清除算法、复制算法、标记-整理算法。

标记-消除算法：当堆中的有效内存被耗尽的时候，就会停止整个系统，就会调用标记-消除算法，主要做两件事，1就是标记，2就是清除。然后让程序恢复。

标记：遍历所有GCroots把可达的对象标记为存活的对象。

清除：把未标记为存活的对象清除掉。

缺点：就是效率相对比较低。会导致stop-the-world时间过长。因为无用的对象内存不是连续的因此清理后的内存也不是连续的，(会产生内存碎片)因此JVM还要维持一个空闲列表，增加一笔开销，同时在以后内存使用时候，去查找可用的内存这个效率也是很低的。

复制算法：这个算法一般适合在新生代GC，将原有的内存分为两块，每次只适用其中的一块，在垃圾回收的时候，将一块正在使用的内存中存活(上述根搜索的算法)的对象复制到另一块没有使用的内存中，原来的那一块全部清除。与上述的标记-清除算法相比效率更高，但是不太适合使用在对象存活较多的情况下(如老年代)。

优点：按顺序分配内存即可，实现简单、运行高效，不用考虑内存碎片。

缺点：每次对整个半区内存回收，因此效率比上面的要高点，同时在分配内存的时候不需要考虑内存的碎片。按照顺序分配内存。简单高效。但是最大的问题在于此算法在对象存活率非常低的时候使用，将可用内存分为两份，每次只使用一份这样极大浪费了内存。

注意（重要）：
现在的虚拟机使用复制算法来进行新生代的内存回收。因为在新生代中绝大多数的对象都是“朝生夕亡”，所以不需要将整个内存分为两个部分，而是分为三个部分，一块为Eden和两块较小的Survivor空间(比例->8:1:1)。每次使用Eden和其中的一块Survivor，垃圾回收时候将上述两块中存活的对象复制到另外一块Survivor上，同时清理上述Eden和Survivor。所以每次新生代就可以使用90%的内存。只有10%的内存是浪费的。(不能保证每次新生代都少于10%的对象存活，当在垃圾回收复制时候如果一块Survivor不够时候，需要老年代来分担，大对象直接进入老年代)

标记-整理算法：(老年代GC)在存活率较高的情况下，复制的算法效率相对比较低，同时还要考虑存活率可能为100%的极端情况，因此又不能把内存分为两部分的复制算法。在上面标记-复制算法的基础之上，演变出了一个新的算法就是标记-整理算法。首先从GCroots开始标记所有可达的对象，标记为存活的对象。然后将存活的对象压缩到内存一端按照内存地址的次序依次排列，然后末端内存地址之后的所有内存都清除。

将标记存活的对象按照内存地址顺序排列到内存另一端，末端内存地址之后的内存都会被清除。

优点：解决了标记-清理算法存在的内存碎片问题。

缺点：仍需要进行局部对象移动，一定程度上降低了效率。

比较：相比较于标记-清除算法 (传统的)，该算法可以解决内存碎片问题同时还可以解决复制算法部分内存不能利用的问题。但是标记-整理算法的效率也不是很高。

上述算法都是根据根节点搜索算法来判断一个对象是不是需要回收，而支撑根节点搜索算法能够正常工作理论依据就是语法中变量作用域的相关内容。

三种算法比较：

效率：复制算法>标记-整理算法>标记-清除算法；

内存整齐度：复制算法=标记-整理算法>标记-清除算法

内存利用率：标记-整理算法=标记-清除算法>复制算法
分代收集算法：

现在使用的Java虚拟机并不是只是使用一种内存回收机制，而是分代收集的算法。就是将内存根据对象存活的周期划分为几块。一般是把堆分为新生代、和老年代。短命对象存放在新生代中，长命对象放在老年代中。

对于不同的代，采用不同的收集算法：

新生代：由于存活的对象相对比较少，因此可以采用复制算法该算法效率比较快。

老年代：由于存活的对象比较多哈，可以采用标记-清除算法或是标记-整理算法（注意）新生态由于根据统计可能有98%对象存活时间很短因此将内存分为一块比较大的Eden空间和两块较小的Survivor空间，每次使用Eden和其中一块Survivor。当回收时，将Eden和Survivor中还存活着的对象一次性地复制到另外一块Survivor空间上，最后清理掉Eden和刚才用过的Survivor空间。
在这里插入图片描述

14. 常见的垃圾回收器

垃圾回收器	工作区域	回收算法	工作线程	用户线程并行	描述
Serial	新生带	复制算法	单线程	否	Client模式下默认新生代收集器。简单高效
ParNew	新生带	复制算法	多线程	否	Serial的多线程版本，Server模式下首选，可搭配CMS的新生代收集器
ParallelScavenge	新生带	复制算法	多线程	否	目标是达到可控制的吞吐量
SerialOld	老年带	标记-整理	单线程	否	Serial老年代版本，给Client模式下的虚拟机使用
ParallelOld	老年带	标记-整理	多线程	否	Parallel Scavenge老年代版本，吞吐量优先
G1	新生带 +老年带	标记-整理 + 复制算法	多线程	是	JDK1.9默认垃圾收集器

Serial收集器（复制算法): 新生代单线程收集器，标记和清理都是单线程，优点是简单高效；

ParNew收集器 (复制算法): 新生代收并行集器，实际上是Serial收集器的多线程版本，在多核CPU环境下有着比Serial更好的表现；

Parallel Scavenge收集器 (复制算法): 新生代并行收集器，追求高吞吐量，高效利用 CPU。吞吐量 = 用户线程时间/(用户线程时间+GC线程时间)，高吞吐量可以高效率的利用CPU时间，尽快完成程序的运算任务，适合后台应用等对交互相应要求不高的场景；

Serial Old收集器 (标记-整理算法): 老年代单线程收集器，Serial收集器的老年代版本；

Parallel Old收集器 (标记-整理算法)：老年代并行收集器，吞吐量优先，Parallel Scavenge收集器的老年代版本；

CMS(Concurrent Mark Sweep)收集器（标记-清除算法）：老年代并行收集器，以获取最短回收停顿时间为目标的收集器，具有高并发、低停顿的特点，追求最短GC回收停顿时间。

G1(Garbage First)收集器 ( 标记整理 + 复制算法来回收垃圾 )： Java堆并行收集器，G1收集器是JDK1.7提供的一个新收集器，G1收集器基于“标记-整理”算法实现，也就是说不会产生内存碎片。此外，G1收集器不同于之前的收集器的一个重要特点是：G1回收的范围是整个Java堆(包括新生代，老年代)，而前六种收集器回收的范围仅限于新生代或老年代。

15. 如何判断一个对象是否存活？

在堆里面存放着Java世界中几乎所有的对象实例，垃圾收集器对堆内存进行回收前，都会先判断这些对象之中哪些还“存活”着，哪些已经“死去”(即不可能在被任何途径使用的对象)。

一共有两种算法：

引用计数算法：给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用的。JVM里面并没有选用引用计数算法来管理内存，主要原因是它很难解决对象之间相互循环引用的问题。

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

16. 深拷贝和浅拷贝？

浅拷贝被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深拷贝深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

17. 什么是分布式垃圾回收（DGC）？它是如何工作的？

RMI 子系统实现基于引用计数的“分布式垃圾回收”(DGC)，以便为远程服务器对象提供自动内存管理设施。当客户机创建（序列化）远程引用时，会在服务器端 DGC 上调用 dirty()。当客户机完成远程引用后，它会调用对应的 clean() 方法。针对远程对象的引用由持有该引用的客户机租用一段时间。租期从收到 dirty() 调用开始。在此类租约到期之前，客户机必须通过对远程引用额外调用 dirty() 来更新租约。如果客户机不在租约到期前进行续签，那么分布式垃圾收集器会假设客户机不再引用远程对象。

18. JVM 中都有哪些引用类型？

强引用：发生 gc 的时候不会被回收。

软引用：有用但不是必须的对象，在发生内存溢出之前会被回收。

弱引用：有用但不是必须的对象，在下一次GC时会被回收。虚引用（幽灵引用/幻影引用）：无法通过虚引用获得对象，用 PhantomReference 实现虚引用，虚引用的用途是在 gc 时返回一个通知。

19 Minor GC、Major GC、Full GC是什么

Minor GC是新生代GC，指的是发生在新生代的垃圾收集动作。由于java对象大都是朝生夕死的，所以Minor GC非常频繁，一般回收速度也比较快。（一般采用复制算法回收垃圾）
Major GC是老年代GC，指的是发生在老年代的GC，通常执行Major GC会连着Minor GC一起执行。Major GC的速度要比Minor GC慢的多。（可采用标记清楚法和标记整理法）
Full GC是清理整个堆空间，包括年轻代和老年代，因为Full GC是清理整个堆空间所以Full GC执行速度非常慢，在Java开发中最好保证少触发Full GC

20. JVM中的永久代中会发生垃圾回收吗

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

21. 讲一下新生代、老年代、永久代的区别

在这里插入图片描述

在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。而新生代 ( Young )又被划分为三个区域：Eden、From Survivor、To Survivor。这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收。

新生代中一般保存新出现的对象，所以每次垃圾收集时都发现大批对象死去，只有少量对象存活，便采用了复制算法，只需要付出少量存活对象的复制成本就可以完成收集。

老年代中一般保存存活了很久的对象，他们存活率高、没有额外空间对它进行分配担保，就必须采用 “标记-清理”或者“标记-整理” 算法。

永久代就是JVM的方法区。在这里都是放着一些被虚拟机加载的类信息，静态变量，常量等数据。这个区中的东西比老年代和新生代更不容易回收。

22. Minor GC、Major GC、Full GC区别及触发条件

Minor GC 触发条件一般为：

eden区满时，触发MinorGC。即申请一个对象时，发现eden区不够用，则触发一次MinorGC。
新创建的对象大小 > Eden所剩空间时触发Minor GC

Major GC和Full GC 触发条件一般为： Major GC通常是跟full GC是等价的

每次晋升到老年代的对象平均大小>老年代剩余空间
MinorGC后存活的对象超过了老年代剩余空间
永久代空间不足
执行System.gc()
CMS GC异常
堆内存分配很大的对象

23. 为什么新生代要分Eden和两个 Survivor 区域？

如果没有Survivor，Eden区每进行一次Minor GC，存活的对象就会被送到老年代。老年代很快被填满，触发Major GC.老年代的内存空间远大于新生代，进行一次Full GC消耗的时间比Minor GC长得多,所以需要分为Eden和Survivor。

Survivor的存在意义，就是减少被送到老年代的对象，进而减少Full GC的发生，Survivor的预筛选
保证，只有经历15次Minor GC还能在新生代中存活的对象，才会被送到老年代。

设置两个Survivor区最大的好处就是解决了碎片化，刚刚新建的对象在Eden中，经历一次Minor GC，Eden中的存活对象就会被移动到第一块survivor space S0，Eden被清空；等Eden区再满了，就再触发一次Minor GC，Eden和S0中的存活对象又会被复制送入第二块survivor space S1（这个过程非常重要，因为这种复制算法保证了S1中来自S0和Eden两部分的存活对象占用连续的内存空间，避免了碎片化的发生）。

24. Java堆老年代( Old ) 和新生代 ( Young ) 的默认比例？

默认的新生代 ( Young ) 与老年代 ( Old ) 的比例的值为 1:2 ( 该值可以通过参数 –XX:NewRatio来指定 )，即：新生代 ( Young ) = 1/3 的堆空间大小。老年代 ( Old ) = 2/3 的堆空间大小。其中，新生代 ( Young ) 被细分为 Eden 和两个 Survivor 区域，Edem 和俩个Survivor 区域比例是 = 8 : 1 : 1 ( 可以通过参数 –XX:SurvivorRatio 来设定 )，但是JVM 每次只会使用 Eden 和其中的一块 Survivor 区域来为对象服务，所以无论什么时候，总
是有一块 Survivor 区域是空闲着的。

25. 为什么要这样分代

其实主要原因就是可以根据各个年代的特点进行对象分区存储，更便于回收，采用最适当的收集算法：
新生代中，每次垃圾收集时都发现大批对象死去，只有少量对象存活，便采用了复制算法，只需要付出少量存活对象的复制成本就可以完成收集。而老年代中因为对象存活率高、没有额外空间对它进行分配担保，就必须采用“标记-清理”或者“标记-整理”算法。

新生代又分为Eden和Survivor （From与To，这里简称一个区）两个区。加上老年代就这三个区。数据会首先分配到Eden区当中（当然也有特殊情况，如果是大对象那么会直接放入到老年代（大对象是指需要大量连续内存空间的java对象）。当Eden没有足够空间的时候就会触发jvm发起一次Minor GC，。如果对象经过一次Minor-GC还存活，并且又能被Survivor空间接受，那么将被移动到Survivor空间当中。并将其年龄设为1，对象在Survivor每熬过一次Minor GC，年龄就加1，当年龄达到一定的程度（默认为15）时，就会被晋升到老年代中了，当然晋升老年代的年龄是可以设置的。

26. 新生代垃圾回收器和老年代垃圾回收器都有哪些？有什么区别？

新生代回收器：Serial、ParNew、Parallel Scavenge

老年代回收器：Serial Old、Parallel Old、CMS

整堆回收器：G1

新生代垃圾回收器一般采用的是复制算法，复制算法的优点是效率高，缺点是内存利用率低；老年代回收器一般采用的是标记-整理的算法进行垃圾回收。

27. 简述分代垃圾回收器是怎么工作的？

分代回收器有两个分区：老生代和新生代，新生代默认的空间占比总空间的 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）时，升级为老生代。大对象也会直接进入老生代。

老生代当空间占用到达某个值之后就会触发全局垃圾收回，一般使用标记整理的执行算法。以上这些循环往复就构成了整个分代垃圾回收的整体执行流程。

28. 对象优先在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倍以上。

29. 为什么大对象直接进入老年代

所谓大对象是指需要大量连续内存空间的对象，频繁出现大对象是致命的，会导致在内存还有不少空间的情况下提前触发 GC 以获取足够的连续空间来安置新对象。

前面我们介绍过新生代使用的是标记-清除算法来处理垃圾回收的，如果大对象直接在新生代分配就会导致 Eden 区和两个 Survivor 区之间发生大量的内存复制。因此对于大对象都会直接在老年代进行分配。

30. 长期存活对象将进入老年代

分配没有足够的空间进行分配时，虚拟机将会发起一次Minor GC。如果本次 GC后还是没有足够的空间，则将启用分配担保机制在老年代中分配内存。

Major GC/Full GC是指发生在老年代的 GC，出现了Major GC通常会伴随至少一次Minor
GC。Major GC的速度通常会比Minor GC慢10倍以上。

29. 为什么大对象直接进入老年代

30. 长期存活对象将进入老年代

虚拟机采用分代收集的思想来管理内存，那么内存回收时就必须判断哪些对象应该放在新生代，哪些对象应该放在老年代。因此虚拟机给每个对象定义了一个对象年龄的计数器，如果对象在 Eden区出生，并且能够被 Survivor 容纳，将被移动到 Survivor 空间中，这时设置对象年龄为 1。对象在 Survivor 区中每「熬过」一次 Minor GC 年龄就加 1，当年龄达到一定程度（默认 15）就会被晋升到老年代。

这篇关于30道JVM综合面试题详解含答案（值得珍藏）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！