面试系列二：精选大数据面试真题 JVM 专项 - 附答案详细解析

公众号（五分钟学大数据）已推出大数据面试系列文章—五分钟小面试，此系列文章将会深入研究各大厂笔面试真题，并根据笔面试题扩展相关的知识点，助力大家都能够成功入职大厂！

大数据笔面试系列文章分为两种类型：混合型（即一篇文章中会有多个框架的知识点—融会贯通）；专项型（一篇文章针对某个框架进行深入解析—专项演练）。

此篇文章为系列文章的第二篇（JVM 专项）

第一题：JVM 内存相关（百度）

问：JVM 内存模型了解吗，简单说下

答：

因为这块内容太多了，许多小伙伴可能记不住这么多，所以下面的答案分为简答和精答。

JVM 运行时内存共分为程序计数器，Java 虚拟机栈，本地方法栈，堆，方法区五个部分：

注：JVM 调优主要就是优化 Heap 堆 和 Method Area 方法区

1. 程序计数器（线程私有）：

简答： 每个线程都有一个程序计算器，就是一个指针，指向方法区中的方法字节码（下一个将要执行的指令代码），由执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不记。

精答：占据一块较小的内存空间，可以看做当前线程所执行的字节码的行号指示器。在虚拟机概念模型里，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支，循环，跳转，异常处理，线程恢复等基础功能都需要依赖这个计数器来完成。

由于 jvm 的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器都只会执行一条线程中的指令。因此未来线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。

如果线程正在执行的是一个 Java 方法，这个计数器记录的则是正在执行的虚拟机字节码指令的地址；

如果正在执行的是 Native 方法，这个计数器则为空（undefined）。

此内存区域是唯一一个在 Java 虚拟机规范中没有规定任何 OutOfMemoryError 情况的区域。

2. Java 虚拟机栈（线程私有）：

>简答：主管 Java 程序的运行，在线程创建时创建，它的生命期是跟随线程的生命期，线程结束栈内存也就释放，对于栈来说不存在垃圾回收问题，只要线程一结束该栈就 Over，生命周期和线程一致，是线程私有的。基本类型的变量和对象的引用变量都是在函数的栈内存中分配。

精答：线程私有，生命周期和线程相同，虚拟机栈描述的是 Java 方法执行的内存模型，每个方法在执行的同时都会创建一个栈帧用于存储局部变量表，操作数栈，动态链接，方法出口等信息。每一个方法从调用直至完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

局部变量表存放了编译期可知的各种基本类型数据（boolean、byte、char、short、int、float、long、double）、对象引用、returnAddress 类型（指向了一条字节码指令的地址）。

其中 64 位长度的 long 和 double 类型的数据会占用 2 个局部变量表空间（slot），其余的数据类型只占用 1 个。局部变量表所需的内存空间在编译期完成分配，当进入一个方法时，这个方法所需要在栈帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表的大小。

在 Java 虚拟机规范中，对此区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将会抛出 Stack OverflowError 异常；如果虚拟机栈可以动态扩展时无法申请到足够的内存，就会抛出 OutOfMemoryError 异常。

1. 本地方法栈（线程私有）：

>简答：本地方法栈为虚拟机中使用到的 native 方法服务，native 方法作用是融合不同的编程语言为 Java 所用，它的初衷是融合 C/C\++程序，Java 诞生的时候 C/C\++横行的时候，要想立足，必须有调用 C/C\++程序，于是就在内存中专门开辟了一块区域处理标记为 native 的代码。

精答：本地方法栈与虚拟机栈所发挥的作用非常相似，他们之间的区别不过是虚拟机栈为虚拟机执行 Java 方法（字节码）服务，而本地方法栈则为虚拟机中使用到的 native 方法服务。在虚拟机规范中对本地方法栈中方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机直接把本地方法栈和虚拟机栈合二为一，与虚拟机栈一样也会抛出 Stack OverflowError 异常和 OutOfMemoryError 异常。

1. Java 堆（线程共享）：

>简答：堆这块区域是 JVM 中最大的，应用的对象和数据都是存在这个区域，这块区域也是线程共享的，也是 gc 主要的回收区，一个 JVM 实例只存在一个堆类存。堆内存的大小是可以调节的。

精答：对于大多数应用来说，堆空间是 jvm 内存中最大的一块。Java 堆是被所有线程共享，虚拟机启动时创建，此内存区域唯一的目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在 Java 虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配，但是随着 JIT 编译器的发展和逃逸分析技术逐渐成熟，栈上分配，标量替换优化技术将会导致一些微妙的变化发生，所有的对象都分配在堆上也就变得不那么绝对了。

Java 堆是垃圾收集器管理的主要区域，因此很多时候也被称为“GC 堆”。从内存回收角度看，由于现在收集器基本都采用分代收集算法，所以 Java 堆还可以细分为：新生代和老年代；再细致一点的有 Eden 空间，From Survivor 空间，To Survivor 空间等。从内存分配的角度来看，线程共享的 Java 堆中可能划分出多个线程私有的分配缓冲区。不过无论如何划分，都与存放内容无关，无论哪个区域，存储的都仍然是对象实例，进一步划分的目的是为了更好的回收内存，或者更快的分配内存。（如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出 OutOfMemoryError 异常。）

1. 方法区（线程共享）：

简答：和堆一样所有线程共享，主要用于存储已被 jvm 加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

精答：方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊方法如构造函数，接口代码也在此定义。简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间。

静态变量，常量，类信息(构造方法/接口定义)，运行时常量池存在方法区中；但是实例变量存在堆内存中，和方法区无关。

在 JDK1.7 发布的 HotSpot 中，已经把字符串常量池移除方法区了。

1. 常量池（线程共享）：：

>简答：运行时常量池是方法区的一部分。用于存放编译期生成的各种字面量和符号引用，它的重要特性是动态性，即 Java 语言并不要求常量一定只能在编译期产生，运行期间也可能产生新的常量，这些常量被放在运行时常量池中。

精答：运行时常量池是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池，用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后进入方法区的运行时常量池中存放。

Java 虚拟机对 class 文件每一部分的格式都有严格规定，每一个字节用于存储哪种数据都必须符合规范才会被 jvm 认可。但对于运行时常量池，Java 虚拟机规范没做任何细节要求。

运行时常量池有个重要特性是动态性，Java 语言不要求常量一定只在编译期才能产生，也就是并非预置入 class 文件中常量池的内容才能进入方法区的运行时常量池，运行期间也有可能将新的常量放入池中，这种特性使用最多的是 String 类的 intern()方法。

既然运行时常量池是方法区的一部分，自然受到方法区内存的限制。当常量池无法再申请到内存时会抛出 outOfMemeryError 异常。

jdk 1.8 同 jdk 1.7 比，最大的差别就是：元数据区取代了永久代。元空间的本质和永久代类似，都是对 JVM 规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元数据空间并不在虚拟机中，而是使用本地内存。

第二题：类加载相关（新浪微博）

问：jvm 加载类的过程主要有哪些，具体怎么加载？

答：

简答：类加载过程即是指 JVM 虚拟机把.class 文件中类信息加载进内存，并进行解析生成对应的 class 对象的过程。分为五个步骤：加载 -> 验证 -> 准备 -> 解析 -> 初始化。加载：将外部的 .class 文件加载到 Java 虚拟机中；验证：确保加载进来的 calss 文件包含的额信息符合 Java 虚拟机的要求；准备：为类变量分配内存，设置类变量的初始值；解析：将常量池内的符号引用 转为 直接引用；初始化：初始化类变量和静态代码块。

精答：前方预警，内容较长，做好准备！

一个 Java 文件从编码完成到最终执行，一般主要包括两个过程：编译、运行

• 编译：即把我们写好的 java 文件，通过 javac 命令编译成字节码，也就是我们常说的.class 文件。

• 运行：则是把编译生成的.class 文件交给 Java 虚拟机(JVM)执行。

而我们所说的类加载过程即是指 JVM 虚拟机把.class 文件中类信息加载进内存，并进行解析生成对应的 class 对象的过程。

• 类加载过程

举个简单的例子来说，JVM 在执行某段代码时，遇到了 class A， 然而此时内存中并没有 class A 的相关信息，于是 JVM 就会到相应的 class 文件中去寻找 class A 的类信息，并加载进内存中，这就是我们所说的类加载过程。

由此可见，JVM 不是一开始就把所有的类都加载进内存中，而是只有第一次遇到某个需要运行的类时才会加载，且只加载一次。

• 类加载

类加载的过程主要分为三个部分：加载、链接、初始化。

而链接又可以细分为三个小部分：验证、准备、解析。

• 加载

简单来说，加载指的是把 class 字节码文件从各个来源通过类加载器装载入内存中。

这里有两个重点：

字节码来源：一般的加载来源包括从本地路径下编译生成的.class 文件，从 jar 包中的.class 文件，从远程网络，以及动态代理实时编译

类加载器：一般包括启动类加载器，扩展类加载器，应用类加载器，以及用户的自定义类加载器。

注：为什么会有自定义类加载器？

一方面是由于 java 代码很容易被反编译，如果需要对自己的代码加密的话，可以对编译后的代码进行加密，然后再通过实现自己的自定义类加载器进行解密，最后再加载。

另一方面也有可能从非标准的来源加载代码，比如从网络来源，那就需要自己实现一个类加载器，从指定源进行加载。

• 验证

主要是为了保证加载进来的字节流符合虚拟机规范，不会造成安全错误。

包括对于文件格式的验证，比如常量中是否有不被支持的常量？文件中是否有不规范的或者附加的其他信息？

对于元数据的验证，比如该类是否继承了被 final 修饰的类？类中的字段，方法是否与父类冲突？是否出现了不合理的重载？

对于字节码的验证，保证程序语义的合理性，比如要保证类型转换的合理性。

对于符号引用的验证，比如校验符号引用中通过全限定名是否能够找到对应的类？校验符号引用中的访问性（private，public 等）是否可被当前类访问？

• 准备

主要是为类变量（注意，不是实例变量）分配内存，并且赋予初值。

特别需要注意，初值，不是代码中具体写的初始化的值，而是 Java 虚拟机根据不同变量类型的默认初始值。

比如 8 种基本类型的初值，默认为 0；引用类型的初值则为 null；常量的初值即为代码中设置的值，final

static tmp = 456， 那么该阶段 tmp 的初值就是 456。

• 解析

将常量池内的符号引用替换为直接引用的过程。

两个重点：

符号引用：即一个字符串，但是这个字符串给出了一些能够唯一性识别一个方法，一个变量，一个类的相关信息。

直接引用：可以理解为一个内存地址，或者一个偏移量。比如类方法，类变量的直接引用是指向方法区的指针；而实例方法，实例变量的直接引用则是从实例的头指针开始算起到这个实例变量位置的偏移量。

举个例子来说，现在调用方法 hello()，这个方法的地址是 1234567，那么 hello 就是符号引用，1234567 就是直接引用。

在解析阶段，虚拟机会把所有的类名，方法名，字段名这些符号引用替换为具体的内存地址或偏移量，也就是直接引用。

• 初始化

这个阶段主要是对类变量初始化，是执行类构造器的过程。

换句话说，只对 static 修饰的变量或语句进行初始化。

如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类。

如果同时包含多个静态变量和静态代码块，则按照自上而下的顺序依次执行。

• 总结

类加载过程只是一个类生命周期的一部分，在其前，有编译的过程，只有对源代码编译之后，才能获得能够被虚拟机加载的字节码文件；在其后还有具体的类使用过程，当使用完成之后，还会在方法区垃圾回收的过程中进行卸载。如果想要了解 Java 类整个生命周期的话，可以自行上网查阅相关资料，这里不再多做赘述。

第三题：JVM 内存相关（云从科技）

问：Java 中会存在内存泄漏吗，请简单描述

答：

理论上 Java 因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是 Java 被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被 GC 回收也会发生内存泄露。

一个例子就是 Hibernate 的 Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象。

下面的例子也展示了 Java 中发生内存泄露的情况：

package com.yuan_more;
import java.util.Arrays;import java.util.EmptyStackException;
public class MyStack<T> {    private  T[] elements;    private int size = 0;
    private static final int INIT_CAPACITY = 16;
    public MyStack(){        elements = (T[]) new Object[INIT_CAPACITY];    }
    public void push(T elem){        ensureCapacity();    }
    public T pop(){        if(size == 0){            throw new EmptyStackException();        }        return elements[-- size];    }
    private void ensureCapacity() {        if(elements.length == size){            elements = Arrays.copyOf(elements,2 * size +1);        }    }}

上面的代码实现了一个栈（先进后出（FILO））结构，乍看之下似乎没有什么明显的问题，它甚至可以通过你编写的各种单元测试。

然而其中的 pop 方法却存在内存泄露的问题，当我们用 pop 方法弹出栈中的对象时，该对象不会被当作垃圾回收，即使使用栈的程序不再引用这些对象，因为栈内部维护着对这些对象的过期引用（obsolete reference）。

在支持垃圾回收的语言中，内存泄露是很隐蔽的，这种内存泄露其实就是无意识的对象保持。

如果一个对象引用被无意识的保留起来了，那么垃圾回收器不会处理这个对象，也不会处理该对象引用的其他对象，即使这样的对象只有少数几个，也可能会导致很多的对象被排除在垃圾回收之外，从而对性能造成重大影响，极端情况下会引发 Disk Paging（物理内存与硬盘的虚拟内存交换数据），甚至造成 OutOfMemoryError。

第四题：垃圾回收相关（滴滴出行）

问：知道 GC 吗？为什么要有 GC？

答：

GC 是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃。

Java 提供的 GC 功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java 语言没有提供释放已分配内存的显示操作方法。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。

要请求垃圾收集，可以调用下面的方法之一：System.gc() 或 Runtime.getRuntime().gc() ，注意，只是请求，JVM 何时进行垃圾回收具有不可预知性。

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

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

第五题：JVM 内存相关（阿里）

问：Hotspot 虚拟机中的堆为什么要有新生代和老年代？

答：

因为有的对象寿命长，有的对象寿命短。应该将寿命长的对象放在一个区，寿命短的对象放在一个区。不同的区采用不同的垃圾收集算法。寿命短的区清理频次高一点，寿命长的区清理频次低一点，提高效率。

所谓的新生代和老年代是针对于分代收集算法来定义的，新生代又分为 Eden 和 Survivor 两个区。加上老年代就这三个区。

数据会首先分配到 Eden 区当中，当然也有特殊情况，如果是大对象那么会直接放入到老年代（大对象是指需要大量连续内存空间的 java 对象）。当 Eden 没有足够空间的时候就会触发 jvm 发起一次 Minor GC。新生代垃圾回收采用的是复制算法。

如果对象经过一次 Minor GC 还存活，并且又能被 Survivor 空间接受，那么将被移动到 Survivor 空间当中。并将其年龄设为 1，对象在 Survivor 每熬过一次 Minor GC，年龄就加 1，当年龄达到一定的程度（默认为 15）时，就会被晋升到老年代中了，当然晋升老年代的年龄是可以设置的。如果老年代满了就执行：Full GC， 因为不经常执行，因此老年代垃圾回收采用了标记-整理（Mark-Compact）算法。