JVM常见面试题

小张学习了吗.

已于 2022-03-21 14:48:49 修改

阅读量372

点赞数

分类专栏： java+juc+jvm 文章标签： java

于 2022-03-19 09:47:07 首次发布

本文链接：https://blog.csdn.net/qq_45514687/article/details/123588494

版权

java+juc+jvm 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

JVM常见面试题

前言
面试常见：
三种JVM:
JVM的体系结构
类加载器
Native
栈
堆（GC堆）
- 堆内存调优
垃圾收集器以及新生代、老年代、永久代
GC（分代收集算法）`没有最好的算法，只有最合适的算法 `
- GC四大算法
JMM
总结

前言

在计算机流传有一句废话：程序 = 算法 + 数据结构

但是对于大部分人都是：程序 = 框架 + 业务逻辑 35危机

面试常见：

请你谈谈你对JVM的理解?
java8虚拟机和之前的变化更新?
什么是OOM，什么是栈溢出StackOverFlowError? 怎么分析?
JVM的常用调优参数有哪些?
内存快照如何抓取？怎么分析Dump文件？
谈谈JVM中，类加载器你的认识？

三种JVM:

Sun公司：HotSpot 用的最多
BEA：JRockit
IBM：J9VM

我们学习都是：HotSpot

JVM的体系结构

在这里插入图片描述

jvm调优：99%都是在方法区和堆，大部分时间调堆。 JNI（java native interface）本地方法接口。
程序计数器（Program Counter Register）：每个线程都有一个程序计数器，是线程私有的，就是一个指针, 指向方法区中的方法字节码(用来存储指向像一条指令的地址，也即将要执行的指令代码)，在执行引擎读取下一条指令, 是一个非常小的内存空间，几乎可以忽略不计

为什么需要程序计数器？记录要执行的代码位置，防止线程切换重新执行
字节码执行引擎修改程序计数器的值

Java 虚拟机栈（Java Virtual Machine Stacks）：每个方法在执行的同时都会在Java 虚拟机栈中创
建一个栈帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息；
栈帧就是Java虚拟机栈中的下一个单位
本地方法栈（Native Method Stack）：内存区域中专门开辟了一块标记区域: Native Method Stack，负责登记native方法，在执行引擎( Execution Engine )执行的时候通过本地方法接口（JNI）加载本地方法库中的方法
凡是带了native关键字的，说明java的作用范围达不到了，回去调用底层c语言的库！
Java 堆（Java Heap）：Java 虚拟机中内存最大的一块，是被所有线程共享的，几乎所有的对象实
例都在这里分配内存；
方法区（Methed Area）：方法区是被所有线程共享,所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义，简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间。
静态变量（static）、常量（final）、类信息(构造方法、接口定义)（Class）、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关

类加载器

类加载器作用：加载.class文件
在这里插入图片描述

类是模板，对象是具体的，通过new来实例化对象。car1，car2，car3，名字在栈里面，真正的实例，具体的数据在堆里面，栈只是引用地址。

类加载流程（三个阶段）：

1.加载阶段

将编译好的class文件加载到内存中（方法区），然后会生成一个代表这个类的Class对象。

2.链接阶段

会为静态变量分配内存并设置默认值。

3.初始化阶段

执行类构造器()进行初始化赋值。

类加载器的分类：

Bootstrap ClassLoader 启动类加载器
Extention ClassLoader 标准扩展类加载器
Application ClassLoader 应用类加载器
User ClassLoader 用户自定义类加载器

双亲委派机制:

package java.lang;

/**
 * @author zhang
 * @create 2022-03-19 08:30
 */
public class String {
    /*
    双亲委派机制:安全
    1.APP-->EXC-->BOOT(最终执行)
    BOOT
    EXC
    APP
     */
    public String toString() {
        return "Hello";
    }

    public static void main(String[] args) {
        String s = new String();
        System.out.println(s.getClass());
        s.toString();
    }
    /*
    1.类加载器收到类加载的请求
    2.将这个请求向上委托给父类加载器去完成，一直向上委托，知道启动类加载
    3.启动加载器检查是否能够加载当前这个类，能加载就结束，使用当前的加载器，否则，抛出异常，适知子加载器进行加载
    4.重复步骤3
     */
}

idea报错

这是因为，在运行一个类之前，首先会在应用程序加载器(APP)中找，如果APP中有这个类，继续向上在扩展类加载器EXC中找，然后再向上，在启动类( 根 )加载器BOOT中找。如果在BOOT中有这个类的话，最终执行的就是根加载器中的。如果BOOT中没有的话，就会倒找往回找。

java双亲委派机制及作用

概念：当某个类加载器需要加载某个.class文件时，它首先把这个任务委托给他的上级类加载器，递归这个操作，如果上级的类加载器没有加载，自己才会去加载这个类。

图解

在这里插入图片描述
如果没有任何加载器能加载，就会抛出ClassNotFoundException

作用：

防止重复加载同一个.class。通过委托去向上面问一问，加载过了，就不用再加载一遍。保证数据安全。
保证核心.class不能被篡改。通过委托方式，不会去篡改核心.class，即使篡改也不会去加载，即使加载也不会是同一个.class对象了。不同的加载器加载同一个.class也不是同一个Class对象。这样保证了Class执行安全。

沙箱安全机制

Java安全模型的核心就是Java沙箱(sandbox)，什么是沙箱?沙箱是一个限制程序运行的环境。沙箱机制就是将Java代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。

沙箱主要限制系统资源访问，例如：CPU、内存、文件系统、网络。不同级别的啥想对这些资源访问的限制也可以不一样

当前最新的安全机制实现，引入了域（Domain）的概念。虚拟机吧所有代码加载到不同的系统域和应用域，系统域部分专门负责与关键资源进行交互。而各个域应用部分则通过系统域的部分代理来对各种需要的资源进行访问。虚拟机中不同的受保护域（Protected Domain），对应不一样的权限（Permission）。存在于不同域中的类文件就具有了当前域的全部权限，下图是最新安全模型

在这里插入图片描述

组成沙箱的基本组件:

字节码校验器(bytecode verifier)︰确保Java类文件遵循lava语言规范。这样可以帮助lava程序实现内存保护。但并不是所有的类文件都会经过字节码校验，比如核心类。
类装载器(class loader) :其中类装载器在3个方面对Java沙箱起作用：

它防止恶意代码去干涉善意的代码;
它守护了被信任的类库边界;
它将代码归入保护域，确定了代码可以进行哪些操作。

类装载器采用的机制是双亲委派模式。

1.从最内层VM自带类加载器开始加载，外层恶意同名类得不到加载从而无法使用;

2.由于严格通过包来区分了访问域，外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效。

存取控制器(access controller)︰存取控制器可以控制核心API对操作系统的存取权限，而这个控制的策略设定，可以由用户指定。
安全管理器(security manager)︰是核心API和操作系统之间的主要接口。实现权限控制，比存取控制器优先级高。
安全软件包(security package) : java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括:
- 安全提供者
- 消息摘要
- 数字签名
- 加密
- 鉴别

Native

start方法的源码：

public synchronized void start() {
      
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            start0();	// 调用了一个start0方法
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
              
            }
        }
    }
	// 这个Thread是一个类，这个方法定义在这里是不是很诡异！看这个关键字native；
    private native void start0();

凡是带了native关键字的，说明 java的作用范围达不到，去调用底层C语言的库！
JNI：Java Native Interface（Java本地方法接口）
凡是带了native关键字的方法就会进入本地方法栈；
Native Method Stack 本地方法栈
本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序，Java在诞生的时候是C/C++横行的时候，想要立足，必须有调用C、C++的程序，于是就在内存中专门开辟了一块区域处理标记为native的代码，它的具体做法是在 Native Method Stack 中登记native方法，在 ( ExecutionEngine ) 执行引擎执行的时候加载Native Libraies。

栈

栈：后进先出 / 先进后出
队列：先进先出（FIFO : First Input First Output）

喝多了吐就是栈，吃多了拉就是队列。

在这里插入图片描述

说明：

1、栈也叫栈内存，主管Java程序的运行，是在线程创建时创建，它的生命期是跟随线程的生命期，线程结束栈内存也就释放。

2、对于栈来说不存在垃圾回收问题，只要线程一旦结束，该栈就Over，生命周期和线程一致，是线程私有的。

3、方法自己调自己就会导致栈溢出（递归死循环测试）。

栈里面会放什么东西那？

8大基本类型 + 对象的引用 + 实例的方法

栈运行原理

Java栈的组成元素——栈帧。
栈帧是一种用于帮助虚拟机执行方法调用与方法执行的数据结构。他是独立于线程的，一个线程有自己的一个栈帧。封装了方法的局部变量表、动态链接信息、方法的返回地址以及操作数栈等信息。
第一个方法从调用开始到执行完成，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

当一个方法A被调用时就产生了一个栈帧F1，并被压入到栈中，A方法又调用了B方法，于是产生了栈帧F2也被压入栈中，B方法又调用了C方法，于是产生栈帧F3也被压入栈中执行完毕后，先弹出F3，然后弹出F2，在弹出F1…

在这里插入图片描述

栈满了，抛出异常：stackOverflowError

在这里插入图片描述

堆（GC堆）

堆内存调优

 // -Xms设置初始化内存分配大小/164
 // -Xmx设置最大分配内存，默以1/4
 // -XX: +PrintGCDetails // 打印GC垃圾回收信息
 // -XX: +HeapDumpOnOutOfMemoryError //oom DUMP
// -Xms1m -Xmx1m -XX:+HeapDumpOnOutOfMemoryError

垃圾收集器以及新生代、老年代、永久代

新生代、老年代、永久代（元空间 : JDK8 以后名称）的区别

在这里插入图片描述

新生代（复制算法）、养老区（ “标记-清理”或者“标记-整理”）

新生区是类诞生，成长，消亡的区域，一个类在这里产生，应用，最后被垃圾回收器收集，结束生命。
新生区又分为两部分：伊甸区（Eden Space）和幸存者区（Survivor Space），所有的类都是在伊甸区被new出来的，幸存区有两个：0区和 1区，当伊甸园的空间用完时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园区进行垃圾回收（Minor GC）。将伊甸园中的剩余对象移动到幸存0区，若幸存0区也满了，再对该区进行垃圾回收，然后移动到1区，那如果1区也满了呢？（这里幸存0区和1区是一个互相交替的过程）再移动到养老区，若养老区也满了，那么这个时候将产生MajorGC（Full GC），进行养老区的内存清理，若养老区执行了Full GC后发现依然无法进行对象的保存，就会产生OOM异常 “OutOfMemoryError ”。如果出现 java.lang.OutOfMemoryError：java heap space异常，说明Java虚拟机的堆内存不够，原因如下：
- Java虚拟机的堆内存设置不够，可以通过参数 -Xms（初始值大小），-Xmx（最大大小）来调整。
- 代码中创建了大量大对象，并且长时间不能被垃圾收集器收集（存在被引用）或者死循环。

永久代

永久存储区是一个常驻内存区域，用于存放JDK自身所携带的Class，Interface的元数据，也就是说它存储的是运行环境必须的类信息，被装载进此区域的数据是不会被垃圾回收器回收掉的，关闭JVM才会释放此区域所占用的内存。
如果出现 java.lang.OutOfMemoryError：PermGen space，说明是 Java虚拟机对永久代Perm内存设置不够。一般出现这种情况，都是程序启动需要加载大量的第三方jar包，
例如：在一个Tomcat下部署了太多的应用。或者大量动态反射生成的类不断被加载，最终导致Perm区被占满。

注意：

- JDK1.6之前： 有永久代，常量池1.6在方法区；
- JDK1.7： 有永久代，但是已经逐步 “去永久代”，常量池1.7在堆；
- JDK1.8及之后：无永久代，常量池1.8在元空间。

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是清理整个堆空间，包括年轻代和老年代

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

Minor GC 触发条件一般为：
1. eden区满时，触发MinorGC。即申请一个对象时，发现eden区不够用，则触发一次
  MinorGC。
2. 新创建的对象大小 > Eden所剩空间时触发Minor GC
Major GC和Full GC 触发条件一般为：·Major GC通常是跟full GC是等价的
1. 每次晋升到老年代的对象平均大小>老年代剩余空间
2. MinorGC后存活的对象超过了老年代剩余空间
3. 永久代空间不足
4. 执行System.gc()
5. CMS GC异常
6. 堆内存分配很大的对象

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

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

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

新生代回收器：Serial、ParNew、Parallel Scavenge
老年代回收器：Serial Old、Parallel Old、CMS
整堆回收器：G1

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

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

所谓大对象是指需要大量连续内存空间的对象，频繁出现大对象是致命的，会导致在内存还有不少空间的情况下提前触发 GC 以获取足够的连续空间来安置新对象。
前面我们介绍过新生代使用的是标记-清除算法来处理垃圾回收的，如果大对象直接在新生代分配
就会导致 Eden 区和两个 Survivor 区之间发生大量的内存复制。因此对于大对象都会直接在老年
代进行分配。

GC（分代收集算法）`没有最好的算法，只有最合适的算法`

GC四大算法

1.引用计数法

在这里插入图片描述

2.复制算法

面试题：如何判断哪个是to区呢？一句话：谁空谁是to

好处：没有内存碎片；坏处：浪费内存空间。
劣势：
1、他浪费了一半的内存，这太要命了。
2、如果对象的存活率很高，我们可以极端一点，假设是100%存活，那么我们需要将所有对象都复制一遍，并将所有引用地址重置一遍。复制这一工作所花费的时间，在对象存活率达到一定程度时，将会变的不可忽视，所以从以上描述不难看出。复制算法要想使用，最起码对象的存活率要非常低才行，而且最重要的是，我们必须要克服50%的内存浪费。

3.标记压缩

在这里插入图片描述

优点：不需要额外的空间！
缺点：两次扫描，严重浪费时间，会产生内存碎片

在这里插入图片描述

在整理压缩阶段，不再对标记的对象作回收，而是通过所有存活对象都像一端移动，然后直接清除边界以外的内存。可以看到，标记的存活对象将会被整理，按照内存地址依次排列，而未被标记的内存会被清理掉，如此一来，当我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可，这比维护一个空闲列表显然少了许多开销。
在整理压缩阶段，不再对标记的对象作回收，而是通过所有存活对象都像一端移动，然后直接清除边界以外的内存。可以看到，标记的存活对象将会被整理，按照内存地址依次排列，而未被标记的内存会被清理掉，如此一来，当我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可，这比维护一个空闲列表显然少了许多开销。

4.标记清除压缩

先标记清除几次，再压缩。

JMM

什么是JMM？
- JMM：（java Memory Model的缩写）
他干嘛的？
- 作用：缓存一致性协议，用于定义数据读写的规则(遵守，找到这个规则)。
- JMM定义了线程工作内存和主内存之间的抽象关系∶线程之间的共享变量存储在主内存(Main Memory)中，每个线程都有一个私有的本地内存（Local Memory)。

在这里插入图片描述

解决共享对象可见性这个问题：volilate
JMM对这八种指令的使用，制定了如下规则：
- 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write。
- 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存。
- 不允许一个线程将没有assign的数据从工作内存同步回主内存。
- 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作。
- 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁。
- 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值。
- 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量。
- 对一个变量进行unlock操作之前，必须把此变量同步回主内存。

MM对这八种操作规则和对volatile的一些特殊规则就能确定哪里操作是线程安全，哪些操作是线程不安全的了。但是这些规则实在复杂，很难在实践中直接分析。所以一般我们也不会通过上述规则进行分析。更多的时候，使用java的happen-before规则来进行分析。

总结

内存效率：复制算法 > 标记清除算法 > 标记压缩算法（时间复杂度）；
内存整齐度：复制算法 = 标记压缩算法 > 标记清除算法；
内存利用率：标记压缩算法 = 标记清除算法 > 复制算法；

可以看出，效率上来说，复制算法是当之无愧的老大，但是却浪费了太多内存，而为了尽量兼顾上面所提到的三个指标，标记压缩算法相对来说更平滑一些，但是效率上依然不尽如人意，它比复制算法多了一个标记的阶段，又比标记清除多了一个整理内存的过程。

年轻代：（Young Gen）

年轻代特点是区域相对老年代较小，对象存活低。
这种情况复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活对象大小有关，因而很适用于年轻代的回收。而复制算法内存利用率不高的问题，通过hotspot中的两个survivor的设计得到缓解。

老年代：（Tenure Gen）

老年代的特点是区域较大，对象存活率高！
这种情况，存在大量存活率高的对象，复制算法明显变得不合适。一般是由标记清除或者是标记清除与标记整理的混合实现。Mark阶段的开销与存活对象的数量成正比，这点来说，对于老年代，标记清除或者标记整理有一些不符，但可以通过多核多线程利用，对并发，并行的形式提标记效率。Sweep阶段的开销与所管理里区域的大小相关，但Sweep “就地处决” 的特点，回收的过程没有对象的移动。使其相对其他有对象移动步骤的回收算法，仍然是是效率最好的，但是需要解决内存碎片的问题。