您的位置: 首页  >  文章  >  面试题整理（JVM虚拟机）

面试题整理（JVM虚拟机）

分类: 文章 • 2024-08-27 18:55:16

1、JVM内存分为哪几个区，每个区的作用是什么？

方法区(线程共享)：

(1)主要用来存储已经被虚拟机加载的类的信息、常量、静态变量和即时编译器编译后的代码等数据

(2)该区域是被线程共享的

(3)很少发生GC，主要是对方法区里的常量池和对类型的卸载

(4)里面有一个运行时常量池，用于存放静态编译产生的字面量和符号引用；具有动态性，用于存储编译期就生成的字面常量、符号引用、翻译出来的直接引用

虚拟机栈(JVM Stack)：(线程私有)

(1)虚拟机栈也就是我们平常所称的栈内存,它为java方法服务，每个方法在执行的时候都会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接和方法出口等信息

(2) 虚拟机栈是线程私有的，它的生命周期与线程相同。

(3) 局部变量表里存储的是基本数据类型；操作数栈的作用主要用来存储运算结果以及运算的操作数，它不同于局部变量表通过索引来访问，而是压栈和出栈的方式；当方法被调用时，栈帧在JVM栈中入栈，当方法执行完成时，栈帧出栈。

(4)每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持方法调用过程中的动态连接.动态链接就是将常量池中的符号引用在运行期转化为直接引用。

(5)局部变量表中存储着方法的相关局部变量，包括各种基本数据类型，对象的引用，返回地址等。在局部变量表中，只有long和double类型会占 用2个局部变量空间（Slot，对于32位机器，一个Slot就是32个bit），其它都是1个Slot。需要注意的是，局部变量表是在编译时就已经确定 好的，方法运行所需要分配的空间在栈帧中是完全确定的，在方法的生命周期内都不会改变。

(6)定义的异常有两种，如果线程调用的栈深度大于虚拟机允许的最大深度，则抛出StatckOverFlowError（栈溢出）；不过多 数Java虚拟机都允许动态扩展虚拟机栈的大小(有少部分是固定长度的)，所以线程可以一直申请栈，知道内存不足，此时，会抛出 OutOfMemoryError（内存溢出）。

 

java对象的访问方式

一般来说，一个Java的引用访问涉及到3个内存区域：JVM栈，堆，方法区。

以最简单的本地变量引用：Object obj = new Object()为例：

Object obj表示一个本地引用存储在JVM栈的本地变量表中，表示一个reference类型数据；

new Object()作为实例对象数据存储在堆中；

堆中还记录了Object类的类型信息（接口、方法、field、对象类型等）的地址，这些地址所执行的数据存储在方法区中；

 

本地方法栈(Native Method Stack)(线程私有)

(1)本地方法栈和虚拟机栈类似，只不过本地方法栈为Native方法服务。

堆(Heap)(线程共享)

(1)java堆是所有线程所共享的一块内存，也是最大的一块。在虚拟机启动时创建，几乎所有的对象实例都在这里创建，因此该区域经常发生垃圾回收操作。对内存在逻辑上是连续的，在实现时可以实固定大小的，也可以是可扩展的，目前主流的虚拟机都是课扩展的，如果没有足够的内存分配，就会抛出内存溢出异常。

程序计数器(线程私有)

(1)内存空间小，字节码解释器工作时通过改变这个计数值可以选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理和线程恢复等功能都需要依赖这个计数器完成。由于程序计数器只是记录当前指令地址，所以不存在内存溢出的情况；该内存区域是唯一一个java虚拟机规范没有规定任何OOM(内存溢出)情况的区域。

 

2、如何判断一个对象是否存活？(或者GC对象的判定方法)

(1)引用计数法

所谓引用计数法就是给每一个对象设置一个引用计数器，每当有一个地方引用这个对象时，就将计数器加一，引用失效时，计数器就减一。当一个对象的引用计数器为零时，说明此对象没有被引用，也就是“死对象”,将会被垃圾回收.

引用计数法有一个缺陷就是无法解决循环引用问题，也就是说当对象A引用对象B，对象B又引用者对象A，那么此时A,B对象的引用计数器都不为零，也就造成无法完成垃圾回收，所以主流的虚拟机都没有采用这种算法。

(2)可达性算法(引用链法)

从一个被称为GC Roots的对象开始向下走做，如果一个对象到GC Roots没有任何引用链相连时，说明此对象不可用。可以作为GC Roots的对象有

虚拟机栈中引用的对象

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

方法区常量池引用的对象

本地方法栈JNI引用的对象

虽然这些算法可以判定一个对象是否能被回收，但是当满足上述条件时，一个对象比不一定会被回收。当一个对象不可达GC Root时，这个对象并 不会立马被回收，而是出于一个死缓的阶段，若要被真正的回收需要经历两次标记

如果对象在可达性分析中没有与GC Root的引用链，那么此时就会被第一次标记并且进行一次筛选，筛选的条件是是否有必要执行finalize()方法。当对象没有覆盖finalize()方法或者已被虚拟机调用过，那么就认为是没必要的。

如果该对象有必要执行finalize()方法，那么这个对象将会放在一个称为F-Queue的对队列中，虚拟机会触发一个Finalize()线程去执行，此线程是低优先级的，并且虚拟机不会承诺一直等待它运行完，这是因为如果finalize()执行缓慢或者发生了死锁，那么就会造成F-Queue队列一直等待，造成了内存回收系统的崩溃。GC对处于F-Queue中的对象进行第二次被标记，这时，该对象将被移除”即将回收”集合，等待回收。

3、简述java垃圾回收机制?

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

 

4、java中垃圾收集的方法有哪些?

标记-清除:

这是垃圾收集算法中最基础的，根据名字就可以知道，它的思想就是标记哪些要被回收的对象，然后统一回收。这种方法很简单，但是会有两个主要问题：1.效率不高，标记和清除的效率都很低；2.会产生大量不连续的内存碎片，导致以后程序在分配较大的对象时，由于没有充足的连续内存而提前触发一次GC动作。

复制算法:

为了解决效率问题，复制算法将可用内存按容量划分为相等的两部分，然后每次只使用其中的一块，当一块内存用完时，就将还存活的对象复制到第二块内存上，然后一次性清楚完第一块内存，再将第二块上的对象复制到第一块。但是这种方式，内存的代价太高每次基本上都要浪费一般的内存。

于是将该算法进行了改进，内存区域不再是按照1：1去划分，而是将内存划分为8:1:1三部分，较大那份内存交Eden区，其余是两块较小的内存区叫Survior区。每次都会优先使用Eden区，若Eden区满，就将对象复制到第二块内存区上，然后清除Eden区，如果此时存活的对象太多，以至于Survivor不够时，会将这些对象通过分配担保机制复制到老年代中。(java堆又分为新生代和老年代)

 标记-整理

该算法主要是为了解决标记-清除，产生大量内存碎片的问题；当对象存活率较高时，也解决了复制算法的效率问题。它的不同之处就是在清除对象的时候现将可回收对象移动到一端，然后清除掉端边界以外的对象，这样就不会产生内存碎片了。

分代收集

现在的虚拟机垃圾收集大多采用这种方式，它根据对象的生存周期，将堆分为新生代和老年代。在新生代中，由于对象生存期短，每次回收都会有大量对象死去，那么这时就采用复制算法。老年代里的对象存活率较高，没有额外的空间进行分配担保，所以可以使用标记-整理 或者 标记-清除。

 

  1. 简述java内存模型？(就是由哪些构成)

面试题整理（JVM虚拟机）

面试题整理（JVM虚拟机）

 

  1. java类加载过程是什么样的(也可以叫做生命周期)？

(1)类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。类的加载的最终产品是位于堆区中的Class对象，Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。

(2)类的生命周期包括这几个部分，加载、连接、初始化、使用和卸载，其中前三部是类的加载的过程,

面试题整理（JVM虚拟机）

  • 加载，查找并加载类的二进制数据，在Java堆中也创建一个java.lang.Class类的对象
  • 连接，连接又包含三块内容：验证、准备、初始化。1）验证，文件格式、元数据、字节码、符号引用验证；2）准备，为类的静态变量分配内存，并将其初始化为默认值；3）解析，把类中的符号引用转换为直接引用
  • 初始化，为类的静态变量赋予正确的初始值
  • 使用，new出对象程序中使用
  • 卸载，执行垃圾回收
  1. 有哪些类加载器？
  1. 启动类加载器：负责加载存放在JDK\jre\lib下并且能被虚拟机识别的类库
  2. 扩展类加载器：负责加载存放在JDK\jre\lib\ext下，开发者能直接使用
  3. 应用类加载器：负责加载用户类路径所指定的类，开发者能直接使用
  4. 用户自定义类加载器：通过继承java.lang.ClassLoader类的方式实现。
  1. 简述Java的类加载机制？

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，解析和初始化，最终形成可以被虚拟机直接使用的java类型。

  • 全盘负责，当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
  • 父类委托，先让父类加载器试图加载该类，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
  • 缓存机制，缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区寻找该Class，只有缓存区不存在，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓存区。这就是为什么修改了Class后，必须重启JVM，程序的修改才会生效

 

  1. 类加载器双亲委派模型机制？

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

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

从年轻代空间（包括 Eden 和 Survivor 区域）回收内存被称为 Minor GC

清理永久代  Major GC

清理整个堆空间包括上面两种  Full GC

  1. 你知道的垃圾收集器有哪些？

    Serial收集器，串行收集器是最古老，最稳定以及效率高的收集器，可能会产生较长的停顿，只使用一个线程去回收。

    ParNew收集器，ParNew收集器其实就是Serial收集器的多线程版本。

    Parallel收集器，Parallel Scavenge收集器类似ParNew收集器，Parallel收集器更关注系统的吞吐量。

    Parallel Old 收集器，Parallel Old是Parallel Scavenge收集器的老年代版本，使用多线程和“标记－整理”算法

    CMS收集器，CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。

    G1收集器，G1 (Garbage-First)是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高概率满足GC停顿时间要求的同时,还具备高吞吐量性能特征

 

 

 

 

 

4 重点补充内容

4.1 String 类和常量池

 

1 String 对象的两种创建方式

String str1 = "abcd";

String str2 = new String("abcd");

System.out.println(str1==str2);//false

 

这两种不同的创建方法是有差别的，第一种方式是在常量池中拿对象，第二种方式是直接在堆内存空间创建一个新的对象。

 

记住：只要使用 new 方法，便需要创建新的对象。

 

2 String 类型的常量池比较特殊。它的主要使用方法有两种：

 

直接使用双引号声明出来的 String 对象会直接存储在常量池中。

如果不是用双引号声明的 String 对象，可以使用 String 提供的 intern 方法。String.intern() 是一个 Native 方法，它的作用是：如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用；如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。

String s1 = new String("计算机");

String s2 = s1.intern();

String s3 = "计算机";

System.out.println(s2);//计算机

System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，

System.out.println(s3 == s2);//true，因为两个都是常量池中的String对象

3 String 字符串拼接

String str1 = "str";

String str2 = "ing";

String str3 = "str" + "ing";//常量池中的对象

String str4 = str1 + str2; //在堆上创建的新的对象     

String str5 = "string";//常量池中的对象

System.out.println(str3 == str4);//false

System.out.println(str3 == str5);//true

System.out.println(str4 == str5);//false

尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用 StringBuilder 或者 StringBuffer。

 

String s1 = new String("abc"); // 这句话创建了几个对象？

创建了两个对象。

验证：

String s1 = new String("abc");// 堆内存的地值值

String s2 = "abc";

System.out.println(s1 == s2);// 输出false,因为一个是堆内存，一个是常量池的内存，故两者是不同的。

System.out.println(s1.equals(s2));// 输出true

结果：

1

2

 

false

true

 

解释：

 

先有字符串 “abc” 放入常量池，然后 new 了一份字符串 “abc” 放入 Java 堆（字符串常量 “abc” 在编译期就已经确定放入常量池，而 Java 堆上的 “abc” 是在运行期初始化阶段才确定），然后 Java 栈的 str1 指向 Java 堆上的 “abc”。

4.2 8种基本类型的包装类和常量池

 

    Java 基本类型的包装类的大部分都实现了常量池技术，即 Byte、Short、Integer、Long、Character、Boolean；这5种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。

    两种浮点数类型的包装类 Float、Double 并没有实现常量池技术。

Integer i1 = 33;

Integer i2 = 33;

System.out.println(i1 == i2);// 输出true

Integer i11 = 333;

Integer i22 = 333;

System.out.println(i11 == i22);// 输出false

Double i3 = 1.2;

Double i4 = 1.2;

System.out.println(i3 == i4);// 输出false

 

Integer 缓存源代码：

/**

 *此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。

 */

public static Integer valueOf(int i) {

    if (i >= IntegerCache.low && i <= IntegerCache.high)

        return IntegerCache.cache[i + (-IntegerCache.low)];

    return new Integer(i);

}

 

应用场景：

 

    Integer i1=40；Java 在编译的时候会直接将代码封装成 Integer i1=Integer.valueOf(40); 从而使用常量池中的对象。

    Integer i1 = new Integer(40) ;这种情况下会创建新的对象。

 

Integer i1 = 40;

Integer i2 = new Integer(40);

System.out.println(i1==i2); //输出false

 

Integer 比较（==）更丰富的一个例子：

Integer i1 = 40;

Integer i2 = 40;

Integer i3 = 0;

Integer i4 = new Integer(40);

Integer i5 = new Integer(40);

Integer i6 = new Integer(0);

 

 

结果：

i1=i2   true

i1=i2+i3   true

i1=i4   false

i4=i5   false

i4=i5+i6   true

40=i5+i6   true

 

解释：

 

语句 i4 == i5 + i6，因为 + 这个操作符不适用于 Integer 对象，首先 i5 和 i6 进行自动拆箱操作，进行数值相加，即 i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。

相关推荐