面试题JVM常见面试题
Posted 早上真起不来！
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了面试题JVM常见面试题相关的知识，希望对你有一定的参考价值。
JVM的内存结构(运行时数据区)?
可以按线程是否私有分为两大类：
- 线程私有的有程序计数器、虚拟机栈、本地方法栈
- 线程共享的有堆、方法区
1、程序计数器：
-
一块较小的内存空间，程序计数器用于保存 JVM 中下一条所要执行的字节码指令的地址！如果正在执行的是 Native 方法，则这个计数器值则为空。程序计数器在硬件层面是通过 寄存器 实现的！
-
CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
-
此区域是唯一一个虚拟机规范中没有规定任何
OutOfMemoryError情况的区域，不会存在内存溢出
Java指令执行流程：
-
.java代码源文件经过编译为.class二进制字节码文件。 -
.class文件中的每一条二进制字节码指令(JVM指令) 通过 解释器 转换成 机器码 然后就可以被 CPU 执行了！ -
当 解释器 将一条 jvm 指令转换成 机器码 后，同时会向程序计数器 递交下一条 jvm 指令的执行地址！
2、Java虚拟机栈：
-
每个线程运行需要的内存空间
-
每个栈由多个栈帧组成，对应着每次调用方法时所占用的内存
-
每个线程只能有一个活动栈帧，对应着当前正在执行的方法是每个线程运行需要的内存空间，每个方法在执行的同时都会创建一个帧栈(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息
Java虚拟机栈的异常状况？
- 虚拟机栈中，栈帧过多（无限递归）或者每个栈帧所占用过大 出现
StackOverflowError异常； - 如果扩展时无法申请到足够的内存，就会抛出
OutOfMemoryError异常。
垃圾回收是否涉及栈内存？
- 不涉及。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
栈内存的分配越大越好吗？
- 不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
方法内的局部变量是否是线程安全的？
- 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
- 如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题
3、本地方法栈：
-
一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法
-
与Java虚拟机栈一样，本地方法栈也会抛出
StackOverflowError和OutOfMemoryError异常
4、堆：
-
所有线程共享，堆内存中的对象都需要考虑线程安全问题
-
在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。也就是说通过new关键字创建的对象都会使用堆内存
-
Java 堆是垃圾收集器管理的主要区域，因此很多时候也被称做“GC 堆”（Garbage）。
-
-Xmx -Xms：JVM初始分配的堆内存由-Xms指定，默认是物理内存的1/64。 -
如果在堆中没有完成实例分配。并且堆也无法扩展时，将会抛出
OutOfMemoryError异常
5、方法区：
- 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
- 方法区的大小决定了系统可以保存多少个类，当方法区无法满足内存分配需求时，将抛出异常
内存溢出
- 1.8以前会导致永久代内存溢出，java.lang.OutOfMemoryError:PermGen space
- 1.8以后会导致元空间内存溢出，java.lang.OutOfMemoryError:Metaspace
方法区的演进？
-
1.6 版本方法区是由永久代实现(使用堆内存的一部分作为方法区)，且由JVM 管理。由Class、ClassLoader、常量池(包括StringTable) 组成。
- 静态变量就存放在永久代(方法区)上。
-
Jdk 1.7 版本仍有永久代，但已经逐步 " 去永久代 "，StringTable、静态变量从永久代移除，保存在堆中。
-
1.8 版本后，方法区交给本地内存管理，而脱离了JVM，由元空间实现(元空间不再使用堆的内存，而是使用本地内存，即操作系统的内存)，由Class、ClassLoader、常量池(StringTable 被移到了堆中管理) 组成。
- 静态变量、StringTable 存放在堆中！
为什么要用元空间取代永久代？
因为永久代有以下几个弊端：
- ① 字符串常量池存在于永久代中，在大量使用字符串的情况下，非常容易出现OOM的异常。
- ② JVM加载的class的总数，方法的大小等都很难确定，因此对永久代大小的指定难以确定。太小的永久代容易导致永久代内存溢出，太大的永久代则容易导致虚拟机内存紧张，空间浪费。
- ③ 永久代进行调优很困难：方法区的垃圾收集主要回收两部分，常量池中废弃的常量和不再使用的类。而不再使用的类或类的加载器回收比较复杂，FULL GC 的时间长。
常量池？
二进制字节码的组成：类的基本信息、常量池、类的方法定义（包含了虚拟机指令）
通过反编译来查看类的信息
-
获得对应类的.class文件
-
在JDK对应的bin目录下运行cmd，也可以在IDEA控制台输入
-
输入 javac 对应类的绝对路径
F:\\JAVA\\JDK8.0\\bin>javac F:\\Thread_study\\src\\com\\nyima\\JVM\\day01\\Main.java输入完成后，对应的目录下就会出现类的.class文件
-
-
在控制台输入 javap -v 类的绝对路径
javap -v F:\\Thread_study\\src\\com\\nyima\\JVM\\day01\\Main.class -
然后能在控制台看到反编译以后类的信息了
-
类的基本信息
-
常量池constant pool
-
虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）
-
运行时常量池？
- 常量池
- 就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
- 运行时常量池
- 常量池是*.class文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址
常量池与串池的关系？
串池StringTable
特征
- 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
- 利用串池的机制，来避免重复创建字符串对象
- 字符串变量拼接的原理是StringBuilder
- 字符串常量拼接的原理是编译器优化
- 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中
- 注意：无论是串池还是堆里面的字符串，都是对象
用来放字符串对象且里面的元素不重复
public class StringTableStudy
public static void main(String[] args)
String a = "a";
String b = "b";
String ab = "ab";
常量池中的信息，都会被加载到运行时常量池中，但这是a b ab 仅是常量池中的符号，还没有成为java字符串
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
9: returnCopy
当执行到 ldc #2 时，会把符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构 不可扩容）
当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中
当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中
最终StringTable [“a”, “b”, “ab”]
注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 ldc #2）时，该字符串才会被创建并放入串池中。
使用拼接字符串变量对象创建字符串的过程
public class StringTableStudy
public static void main(String[] args)
String a = "a";
String b = "b";
String ab = "ab";
//拼接字符串对象来创建新的字符串
String ab2 = a+b;
反编译后的结果
Code:
stack=2, locals=5, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
9: new #5 // class java/lang/StringBuilder
12: dup
13: invokespecial #6 // Method java/lang/StringBuilder."<init>":()V
16: aload_1
17: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
20: aload_2
21: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
24: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
27: astore 4
29: returnCopy
通过拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()
最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中
String ab = "ab";
String ab2 = a+b;
//结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中
System.out.println(ab == ab2);
使用拼接字符串常量对象的方法创建字符串
public class StringTableStudy
public static void main(String[] args)
String a = "a";
String b = "b";
String ab = "ab";
String ab2 = a+b;
//使用拼接字符串的方法创建字符串
String ab3 = "a" + "b";
System.out.println(ab == ab2); // false
System.out.println(ab == ab3); // true
System.out.println(ab2 == ab3); // false
反编译后的结果
Code:
stack=2, locals=6, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
9: new #5 // class java/lang/StringBuilder
12: dup
13: invokespecial #6 // Method java/lang/StringBuilder."<init>":()V
16: aload_1
17: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
20: aload_2
21: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
24: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
27: astore 4
//ab3初始化时直接从串池中获取字符串
29: ldc #4 // String ab
31: astore 5
33: returnCopy
- 使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致。
- 使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建
intern方法 1.8
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，则放入成功
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象
例1
public class Main
public static void main(String[] args)
//"a" "b" 被放入串池中，str则存在于堆内存之中
String str = new String("a") + new String("b");
//调用str的intern方法，这时串池中没有"ab"，则会将该字符串对象放入到串池中，此时堆内存与串池中的"ab"是同一个对象
String st2 = str.intern();
//给str3赋值，因为此时串池中已有"ab"，则直接将串池中的内容返回
String str3 = "ab";
//因为堆内存与串池中的"ab"是同一个对象，所以以下两条语句打印的都为true
System.out.println(str == st2);
System.out.println(str == str3);
例2
public class Main
public static void main(String[] args)
//此处创建字符串对象"ab"，因为串池中还没有"ab"，所以将其放入串池中
String str3 = "ab";
//"a" "b" 被放入串池中，str则存在于堆内存之中
String str = new String("a") + new String("b");
//此时因为在创建str3时，"ab"已存在与串池中，所以放入失败，但是会返回串池中的"ab"
String str2 = str.intern();
//false
System.out.println(str == str2);
//false
System.out.println(str == str3);
//true
System.out.println(str2 == str3);
intern方法 1.6
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
注意：此时无论调用intern方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象
StringTable 垃圾回收？
StringTable在内存紧张时，会发生垃圾回收
StringTable调优？
-
因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间
-XX:StringTableSize=xxxx -
考虑是否需要将字符串对象入池
可以通过intern方法减少重复入池
6、直接内存
- 属于操作系统，常见于NIO操作时，用于数据缓冲区
- 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
文件读写流程
使用了DirectBuffer
直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率
释放原理？
直接内存的回收不是通过JVM的垃圾回收来释放的，而是通过unsafe.freeMemory来手动释放
通过
//通过ByteBuffer申请1M的直接内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);
申请直接内存，但JVM并不能回收直接内存中的内容，它是如何实现回收的呢？
allocateDirect的实现
public static ByteBuffer allocateDirect(int capacity)
return new DirectByteBuffer(capacity);
DirectByteBuffer类
DirectByteBuffer(int cap) // package-private
super(-1, 0, cap, cap);
boolean pa = VM.isDirectMemoryPageAligned();
int ps = Bits.pageSize();
long size = Math.max(1L, (long)cap + (pa ? ps : 0));
Bits.reserveMemory(size, cap);
long base = 0;
try
base = unsafe.allocateMemory(size); //申请内存
catch (OutOfMemoryError x)
Bits.unreserveMemory(size, cap);
throw x;
unsafe.setMemory(base, size, (byte) 0);
if (pa && (base % ps != 0))
// Round up to page boundary
address = base + ps - (base & (ps - 1));
else
address = base;
cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); //通过虚引用，来实现直接内存的释放，this为虚引用的实际对象
att = null;
这里调用了一个Cleaner的create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象（这里是DirectByteBuffer）被回收以后，就会调用Cleaner的clean方法，来清除直接内存中占用的内存
public void clean()
if (remove(this))
try
this.thunk.run(); //调用run方法
catch (final Throwable var2)
AccessController.doPrivileged(new PrivilegedAction<Void>()
public Void run()
if (System.err != null)
(new Error("Cleaner terminated abnormally", var2)).printStackTrace();
System.exit(1);
return null;
);
Copy
对应对象的run方法
public void run()
if (address == 0)
// Paranoia
return;
unsafe.freeMemory(address); //释放直接内存中占用的内存
address = 0;
Bits.unreserveMemory(size, capacity);
Copy
直接内存的回收机制总结
- 使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法 可以参考【JDK源码】魔法类Unsafe
- ByteBuffer的实现内部使用了Cleaner（虚引用）来检测ByteBuffer。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存
JVM 是如何判断对象可以被回收的？
两种算法：引用计数法、可达性分析算法
1、引用计数法
- 如果一个对象被其他变量所引用，则让该对象的引用计数
+1，如果该对象被引用 2 次则其引用计数为 2，依次类推。 - 某个变量不再引用该对象，则让该对象的引用计数
-1，当该对象的引用计数变为0 时，则表示该对象没用被其他变量所引用，这时候该对象就可以被作为垃圾进行回收。
引用计数法弊端：循环引用时，两个对象的引用计数都为 1 ，导致两个对象都无法被释放回收。最终就会造成内存泄漏！
2、可达性分析算法
- JVM中的垃圾回收器通过可达性分析来探索所有存活的对象
- 扫描堆中的对象，看能否沿着GC Root(根对象，就是肯定不会被当成垃圾回收的对象)对象为起点的引用链找到该对象，如果找不到，则表示可以回收
- 可以作为GC Root的对象
- 虚拟机栈（栈帧中的本地变量表）中引用的对象。
- 方法区中类静态属性引用的对象
- 方法区中常量引用的对象
- 本地方法栈中JNI（即一般说的Native方法）引用的对象
但一个对象满足上述条件的时候，不会马上被回收，还需要进行两次标记;第一次标记：判断当前对象是否有finalize()方法并且该方法没有被执行过，若不存在则标记为垃圾对象，等待回收;若有的话，则进行第二次标记；第二次标记将当前对象放入F-Queue队列，并生成一个finalize线程去执行该方法，虚拟机不保证该方法一定会被执行，这是因为如果线程执行缓慢或进入了死锁，会导致回收系统的崩溃；如果执行了finalize方法之后仍然没有与GCRoots有直接或者间接的引用，则该对象会被回收;
java 中的 五种引用？
1、强引用
- 只要沿着 GC Root的引用链能够找到该对象，就不会被垃圾回收；只有当GC Root 都不引用该对象时，才会回收强引用对象。
- 换句话说就是，只要强引用存在，JVM 垃圾回收器就永远都不会回收被引用的对象，即使内存不足，JVM 会抛出
OutOfMemoryError。
比如，new 一个对象 Student ，将对象 Student 通过=(赋值运算符)，赋值给变量 stu，则变量 stu就强引用了对象 Student。
// 只要 stu 指向 Student 对象，那它就是强引用，永远都不会被 JVM 回收
Student stu = new Student();
// 如果将 stu 置为 null，可以切断 GC Root 引用链，这样 stu 就会被 JVM 回收
stu = null;
2、软引用
- 如果仅有软引用引用某个对象时，在垃圾回收后，内存仍不足时会再次触发垃圾回收，回收软引用对象。即，在内存足够时，JVM 不会回收软引用对象，但当内存不足时，软引用对象就会被回收，所以软引用对象通常用来描述一些非必要但仍有用的对象。
// 不直接通过 list 引用 byte[]
// list -----> SoftReference -----> byte[] 添加了一层软引用:
List<SoftReference<byte[]>> list = new ArrayList<>();
如果想要清理软引用，需要使用引用队列
public class Demo1
public static void main(String[] args)
final int _4M = 4*1024*1024;
//使用引用队列，用于移除引用为空的软引用对象
ReferenceQueue<byte[]> queue = new ReferenceQueue<>();
//使用软引用对象 list和SoftReference是强引用，而SoftReference和byte数组则是软引用
List<SoftReference<byte[]>> list = new ArrayList<>();
SoftReference<<以上是关于面试题JVM常见面试题的主要内容，如果未能解决你的问题，请参考以下文章