首页  思维导图  详情

java-JVM

2020-10-28 11:24:54   0  举报





AI智能生成

面试中JVM相关问题

javaJVM面试题汇总

作者其他创作

大纲/内容

JVM如何加载.class文件

组成

JVM包含两个子系统和两个组件，两个子系统为Class loader(类装载)、Execution engine(执行引擎)；

Class loader(类装载)：根据给定的全限定名类名(如：java.lang.Object)来装载class文件到Runtime data area中的method area。

Execution engine（执行引擎）：执行classes中的指令。

两个组件为Runtime data area(运行时数据区)、Native Interface(本地接口)。

Native Interface(本地接口)：与native libraries交互，是其它编程语言交互的接口。

Runtime data area(运行时数据区域)：这就是我们常说的JVM的内存。

作用:

首先通过编译器把 Java 代码转换成字节码，类加载器（ClassLoader）再把字节码加载到内存中，将其放在运行时数据区（Runtime data area）的方法区内，而字节码文件只是 JVM 的一套指令集规范，并不能直接交给底层操作系统去执行，因此需要特定的命令解析器执行引擎（Execution Engine），将字节码翻译成底层系统指令，再交由 CPU 去执行，而这个过程中需要调用其他语言的本地库接口（Native Interface）来实现整个程序的功能。

class文件里面内容怎么看

谈谈反射

理解：

java的反射机制时在非运行状态中，对于任意一个类，都能够直到这个类的所有属性和方法；

对于任意一个对象都能够调用它的任意方法和属性；

这种动态获取信息以及动态调用对象方法的功能成为java的反射机制

反射的例子

Class rc = Class.forName("com.interview.javabasic.reflect.Robot");
Robot r = (Robot) rc.newInstance();
System.out.println("Class name is " + rc.getName());
Method getHello = rc.getDeclaredMethod("throwHello", String.class);
getHello.setAccessible(true);
Object str = getHello.invoke(r, "Bob");
System.out.println("getHello result is " + str);
Method sayHi = rc.getMethod("sayHi", String.class);
sayHi.invoke(r, "Welcome");
Field name = rc.getDeclaredField("name");
name.setAccessible(true);
name.set(r, "Alice");
sayHi.invoke(r, "Welcome");
System.out.println(System.getProperty("java.ext.dirs"));
System.out.println(System.getProperty("java.class.path"));

对象的创建

过程

虚拟机遇到一条new指令时，先检查常量池是否已经加载相应的类，如果没有，必须先执行相应的类加载。

类加载通过后，接下来分配内存。若Java堆中内存是绝对规整的，使用“指针碰撞“方式分配内存；如果不
是规整的，就从空闲列表中分配，叫做”空闲列表“方式。

划分内存时还需要考虑一个问题-并发，也有两种方式: CAS同步处理，或者本地线程分配缓冲
(Thread Local Allocation Buffer, TLAB)。然后内存空间初始化操作，接着是做一些必要的对
象设置(元信息、哈希码…)，最后执行<init>方法。

内存分配的两种方式

指针碰撞

如果Java堆的内存是规整，即所有用过的内存放在一边，而空闲的的放在另一边。
分配内存时将位于中间的指针指示器向空闲的内存移动一段与对象大小相等的距离
，这样便完成分配内存工作。

空闲列表

如果Java堆的内存不是规整的，则需要由虚拟机维护一个列表来记录那些内存是可用的，
这样在分配的时候可以从列表中查询到足够大的内存分配给对象，并在分配后更新列表记录。

处理并发安全问题

同步处理

对分配内存空间的动作进行同步处理（采用 CAS + 失败重试来保障更新操作的原子性）；

本地线程分配缓冲

把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在 Java 堆中
预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer, TLAB）。
哪个线程要分配内存，就在哪个线程的 TLAB 上分配。只有 TLAB 用完并分配新的 TLAB 时，
才需要同步锁

对象的访问定位

指针：指向对象，代表一个对象在内存中的起始地址。

句柄：可以理解为指向指针的指针，维护着对象的指针。句柄不直接指向对象，
而是指向对象的指针（句柄不发生变化，指向固定内存地址），再由对象的指
针指向对象的真实内存地址。

内存泄漏

定义：内存泄漏是指不再被使用的对象或者变量一直被占据在内存中

场景：Java也还是存在着内存泄漏的情况，java导致内存泄露的原因很明确：
长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管
短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导
致不能被回收，这就是java中内存泄露的发生场景。

内存溢出（OOM）

原因：

1、内存中加载的数据量过于庞大，如一次从数据库取出过多数据；

2、集合类中有对对象的引用，使用完后未清空，使得JVM不能回收；

3、代码中存在死循环或循环产生过多重复的对象实体；

4、使用的第三方软件中的BUG；

5、启动参数内存值设定的过小

怎么解决

第一步，修改JVM启动参数，直接增加内存。(-Xms，-Xmx参数一定不要忘记加。)

第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。

第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

ClassLoader

理解

Class Loader在java中有个非常重要的作用，它主要工作在Class装载的加载阶段，
其主要作用是从系统外部获得Class二进制数据流。它是java的核心组件，所有的
Class都是由ClassLoader进行加载的，ClassLoader负责通过将Class文件里的二
进制数据流装在进系统，然后交给java虚拟机进行连接，初始化等操作

类加载器种类

BootStrapClassLoader: C++编写，加载核心java*

extensions ClassLoader：java编写，加载扩展库java.*

AppClassLoader：java编写，加载程序所在目录

自定义ClassLoader：java编写，定制化加载

关键函数

说一下类装载的执行过程？

加载：根据查找路径找到相应的 class 文件然后导入；

验证：检查加载的 class 文件的正确性；

准备：给类中的静态变量分配内存空间；

解析：虚拟机将常量池中的符号引用替换成直接引用的过程。符号引用就理解为一个标示，而在直接引用直接指向内存中的地址；

初始化：对静态变量和静态代码块执行初始化工作。

使用双亲委派机制去加载类

流程图

介绍：

当一个类收到了类加载请求时，不会自己先去加载这个类，而是将其委派给父类，由父类去加载，如果此时父类不能加载，反馈给子类，由子类去完成类的加载。

为什么使用

1、防止重复加载同一个`.class`。通过委托去向上面问一问，加载过了，就不用再加载一遍。保证数据安全。

2、保证核心`.class`不能被篡改。通过委托方式，不会去篡改核心`.class`，不同的加载器加载同一个`.class`也不是同一个`Class`对象。这样保证了`Class`执行安全。

类的加载/装载方式

隐式加载：new

显式加载：loadClass、forName

区别

Class.forName得到的class是已经初始化完成的

Classloader.loadClass得到的class是还没有链接的

类的加载过程

加载

通过ClassLoader加载class文件字节码，生成Class对象

链接

校验：检查加载的class的正确性和安全性

准备：为类变量分配存存储空间并设置类变量初始值

解析：JVM将常量池内的符号引用转换为直接引用

初始化

执行类变量赋值和静态代码块

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

内存模型

简介

内存简介

地址空间划分

内核空间

用户空间

JDK8

程序计数器

当前线程所执行的字节码行号指示器（逻辑）

改变计数器的值来选取下一条需要执行的字节码指令

和线程是一对一的关系即“线程私有”

对java方法计数，如果是Native方法则计数器值为Undefined

不会发生内存泄漏

java虚拟机栈

java方法执行的内存模型

用于存储局部变量表、操作数栈、动态链接、方法出口等信息；

本地方法栈

与虚拟机栈的作用是一样的，只不过虚拟机栈是服务 Java 方法的，而本地方法栈是为虚拟机调用 Native 方法服务的；

Java 堆（Java Heap）

Java 虚拟机中内存最大的一块，是被所有线程共享的，几乎所有的对象实例都在这里分配内存；

方法区（Methed Area）

用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数据。

线程共享

元空间（MetaSpace）与永久代（PermGen）的区别

元空间使用本地内存，而永久代使用的是jvm的内存

MetaSpace相比PermGen优势

字符串常量池在永久代中，容易出现性能问题和内存溢出

类方法的信息大小难以确定，给永久代的大小指定带来困难

永久代会为GC带来不必要的复杂性

方便HotSpot与其他JVM如Jrockit的集成

Java堆（Heap）

对象实例的分配区域

GC管理的主要区域

常见面试问题

1、JVM三大性能调优参数

-Xss:规定了每个线程虚拟机栈（堆栈）的大小

-Xms：堆的初始值

-Xmx：堆能达到的最大值

2、java内存模型中的堆和栈的区别

首先了解下内存分配策略

静态存储：编译时确定每个数据目标在运行时的存储空间需求

栈式存储：数据需求在编译时未知，运行时模块入口前确定

堆式存储：编译时或运行时模块入口都无法确定，动态分配

联系：

引用对象，数组时，栈里定义变量保存堆中目标的首地址

区别

管理方式：栈自动释放，堆需要GC

空间大小：栈比堆小

碎片相关：栈产生的碎片要远小于堆

分配方式：栈支持动态和静态；堆仅支持动态分配

效率：栈的效率比堆高

3、不同JDK版本置键的intern（）方法的区别

简述java内存分配与回收策率以及Minor GC和Major GC

对象的内存分配通常是在 Java 堆上分配，对象主要分配在新生代的 Eden 区，如果启动了本地线程缓冲，
将按照线程优先在 TLAB 上分配。少数情况下也会直接在老年代上分配。

对象优先在 Eden 区分配

多数情况，对象都在新生代 Eden 区分配。当 Eden 区分配没有足够的空间进行分配时，
虚拟机将会发起一次 Minor GC。如果本次 GC 后还是没有足够的空间，则将启用分配
担保机制在老年代中分配内存。

大对象直接进入老年代

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

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

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

Minor GC 是指发生在新生代的 GC，因为 Java 对象大多都是朝生夕死，所有 Minor GC 非常频繁，一般回收速度也非常快；

当Eden区满时，触发Minor GC。

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

GC模块

理解

在JVM中，有一个垃圾回收线程，它是低优先级的，在正常情况下是不会执行的，
只有在虚拟机空闲或者当前堆内存不足时，才会触发执行，扫面那些没有被任何
引用的对象，并将它们添加到要回收的集合中，进行回收。

垃圾回收器的基本原理是什么？
垃圾回收器可以马上回收内存吗？
有什么办法主动通知虚拟机进行垃圾回收？

对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。

通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。

可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

Java 中都有哪些引用类型？

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

eg:Object obj = new Object();

抛出OutOfMemoryError终止程序也不会回收具有强引用的对象

通过将对象设置未null来弱化引用，使其被回收

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

eg：String str = new String("abc")；//强引用
SoftReference<String> softRef = new SoftReference<String>(Str);//软引用

对象储在有用但非必须状态

只有当内存空间不足时，GC会回收该引用的对象的内存

可以用来实现高速缓存

弱引用：有用但不是必须的对象，在下一次GC时会被回收。

eg: WeakReference<String> aaa = new WeakReference<String>(str)

非必须的对象，比软引用更弱一些

GC时会被收回

被收回的概率也不大，因为GC线程优先级比较低

适用于引用偶尔被使用且不影响垃圾收集的对象

虚引用（幽灵引用/幻影引用）：无法通过虚引用获得对象，用 PhantomReference 实现虚引用，虚引用的用途是在 gc 时返回一个通知。

例子：ReferenceQueue queue = new Reference();
PhantomReference ref = new PhantomReference(str,queue);

不会决定对象的声明周期

任何时候都可能被垃圾收集器回收

跟踪对象被垃圾收集器回收的活动，起哨兵作用

必须和引用队列ReferenceQueue联合使用

怎么判断对象是否可以被回收？

引用计数器法

为每个对象创建一个引用计数，有对象引用时计数器 +1，引用被释放时计数 -1，当计数器为 0 时就可以被回收。它有一个缺点不能解决循环引用的问题；

可达性分析算法

从 GC Roots 开始向下搜索，搜索所走过的路径称为引用链。当一个对象到 GC Roots 没有任何引用链相连时，则证明此对象是可以被回收的。

可以作为GC Root的对象

虚拟机中引用的对象

方法区中常量引用的对象

方法区中的类静态属性引用的对象

本地方法栈中的JNI（native方法）的引用对象

活跃线程的引用对象

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

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

JVM 有哪些垃圾回收算法？

标记-清除算法

标记存活对象，然后对堆内存从头到尾进行线性遍历，回收不可达对象内存。

缺点：碎片化，垃圾清除后内存不连续，内存利用率低下

优点：实现简单，不需要对象进行移动。

复制算法

按照容量划分二个大小相等的内存区域，当一块用完的时候将活着的对象复制到另一块上，
然后再把已使用的内存空间一次清理掉。

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

缺点：可用的内存大小缩小为原来的一半，对象存活率高时会频繁进行复制。

标记-整理算法

标记无用对象，让所有存活的对象都向一端移动，然后直接清除掉端边界以外的内存。

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

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

分代算法

根据对象存活周期的不同将内存划分为几块，一般是新生代和老年代，新生代基本采用复制
算法，老年代采用标记整理算法。一般包括年轻代、老年代和永久代

说一下 JVM 有哪些垃圾回收器？

图

7种作用于不同分代的收集器，其中用于
回收新生代的收集器包括Serial、PraNew、Parallel Scavenge，
回收老年代的收集器包括Serial Old、Parallel Old、CMS，
还有用于回收整个Java堆的G1收集器。
不同收集器之间的连线表示它们可以搭配使用。

Serial收集器（-XX:+UseSerialGC，复制算法)

新生代单线程收集器，标记和清理都是单线程，收集时必须暂停所有工作线程，优点是简单高效；

ParNew收集器 (-XX:+UseParNewGC 复制算法)

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

Parallel Scavenge收集器 (-XX:+UseParallelGC 复制算法)

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

Serial Old收集器 (-XX:+UseSerialOldGC 标记-整理算法)

老年代单线程收集器，Serial收集器的老年代版本；

Parallel Old收集器 (-XX:+UseParallelOldGC 标记-整理算法)

老年代并行收集器，吞吐量优先，Parallel Scavenge收集器的老年代版本；

CMS(Concurrent Mark Sweep)收集器（标记-清除算法）

老年代并行收集器，以获取最短回收停顿时间为目标的收集器，具有高并发、低停顿的特点，追求最短GC回收停顿时间。

CMS 是英文 Concurrent Mark-Sweep 的简称，是以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器。对于要求服务器响应速度的应用上，这种垃圾回收器非常适合。在启动 JVM 的参数加上“-XX:+UseConcMarkSweepGC”来指定使用 CMS 垃圾回收器。

CMS 使用的是标记-清除的算法实现的，所以在 gc 的时候回产生大量的内存碎片，当剩余内存不能满足程序运行要求时，系统将会出现 Concurrent Mode Failure，临时 CMS 会采用 Serial Old 回收器进行垃圾清除，此时的性能将会被降低。

G1(Garbage First)收集器 (标记-整理算法)

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

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

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

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

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

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

常用调优参数

-XX：SurvivorRatio：Eden和Survivor的比值，默认8：1

-XX:NewRatio：老年代和年轻代内存大小的比例

-XX:MaxTenuringThreshold：对象从年轻代晋升到老生代经过GC次数的最大阈值

常见的参数意思

Stop-the-world

JVM由于要执行GC而停止了应用程序的执行

任何一种GC算法中都会发生

多数GC优化通过减少Stop-the-world发生事件来提高程序的性能

Safepoint

分析过程中对象引用关系不会发生变化的点

产生Safepoint的地方：方法调用；循环跳转；异常跳转等

安全点适中

java的运行模式

Server

Client

常见GC面试题

Object的finallize()方法的作用是否与C++中的析构函数作用相同

与C++的析构函数不同，析构函数调用确定，而它的时不确定的

将未被引用的对象放置于F-Queue队列

方法执行随时可能会被终止

给予对象最后一次重生的机会

引用队列（ReferenceQueue）

无实际存储结构，存储逻辑依赖内部节点置键的关系来表达、

存储相关联的且被GC的软引用，弱引用以及虚引用

JVM锁优化和膨胀过程⭐

自旋锁

自旋锁其实就是在拿锁时发现已经有线程拿了锁，自己如果去拿会阻塞自己，这个时候会选择进行一次忙循环尝试。也就是不停循环看是否能等到上个线程自己释放锁。自适应自旋锁指的是例如第一次设置最多自旋10次，结果在自旋的过程中成功获得了锁，那么下一次就可以设置成最多自旋20次。

锁粗化

虚拟机通过适当扩大加锁的范围以避免频繁的拿锁释放锁的过程。

锁消除

通过逃逸分析发现其实根本就没有别的线程产生竞争的可能（别的线程没有临界量的引用），或者同步块内进行的是原子操作，而“自作多情”地给自己加上了锁。有可能虚拟机会直接去掉这个锁。

偏向锁

在大多数的情况下，锁不仅不存在多线程的竞争，而且总是由同一个线程获得。因此为了让线程获得锁的代价更低引入了偏向锁的概念。偏向锁的意思是如果一个线程获得了一个偏向锁，如果在接下来的一段时间中没有其他线程来竞争锁，那么持有偏向锁的线程再次进入或者退出同一个同步代码块，不需要再次进行抢占锁和释放锁的操作。

轻量级锁

当存在超过一个线程在竞争同一个同步代码块时，会发生偏向锁的撤销。当前线程会尝试使用CAS来获取锁，当自旋超过指定次数(可以自定义)时仍然无法获得锁，此时锁会膨胀升级为重量级锁。

重量级锁

重量级锁依赖对象内部的monitor锁来实现，而monitor又依赖操作系统的MutexLock（互斥锁）。当系统检查到是重量级锁之后，会把等待想要获取锁的线程阻塞，被阻塞的线程不会消耗CPU，但是阻塞或者唤醒一个线程，都需要通过操作系统来实现。

触发Full GC条件

老年代空间不足

永久代空间不足

CMS GC时出现promotion failed ,concurrent mode failure

Minor GC晋升到老年代的平局大小大于老年代的剩余空间

调用System.gc()-----可能会触发

使用RMI来进行RPC或管理的JDK

CMS收集器（-xx:+UseConcMarkSweepGC）