Java/面试题：Java 虚拟机
Java19 分钟 读完 (大约 2865 个字)

Java/面试题：Java 虚拟机

  • 平台无关性是通过 字节码 + 虚拟机来实现的。Java 源码首先被编译成字节码，再由不同平台的 JVM 进行解析，在不同而平台上运行时不需要重新编译。Java 虚拟机在执行字节码的时候，把字节码转换成具体平台上的机器指令。
  • 为什么 JVM 不直接将源代码编译成机器指令去执行？
    • 如果 JVM 直接将源代码编译成机器指令去执行，那么每次编译都需要进行各种检查
    • 从兼容性方面考虑，也可以将别的语言编译成字节码，增加了 JVM 这个平台的兼容扩展能力
  • Java 虚拟机包括四个部分
    • Class loader：根据特定格式，加载 Class 文件到内存
      • BootStrapClassLoader：C++ 编写，加载 Java 核心库 java.*
      • ExtClassLoader：Java 编写，加载扩展库 javax.*
      • AppClassLoader：Java 编写，加载程序所在目录
      • 自定义 ClassLoader：Java 编写，定制化加载，可以通过网络远程加载类，可以对字节码进行加解密，可以使用 ASM 字节码增强来修改字节码
      • 为什么使用双亲委派机制去加载类：避免多份同样字节码的加载
      • 类加载过程
        1. 加载：通过 ClassLoader 加载 class 字节码，生成 Class 对象
        2. 链接：包括校验(检查加载的 Class 的正确性和安全性)、准备(为类变量分配存储空间并设置类变量初始值)、解析(JVM 将常量池内的符号引用转换为直接引用)
        3. 初始化：执行类变量赋值和静态代码块
      • 类的加载方式有隐式加载(new 关键字)和显式加载(loadClass, forName)
      • loadClass 和 forName 的区别：Class.forName() 得到的 class 是已经完成初始化了的(加载 MySQL 驱动时，代码中有静态代码块，如果使用 loadClass 方法加载则不会运行静态代码块，必须使用此方法加载)；Classloader.loadClass() 得到的 class 是还没有链接的(大量用于 Spring IOC 的延迟加载中，不需要执行类加载的链接和初始化步骤，可以加快加载速度，等到实际需要使用类的时候才去初始化)。
    • Execution Engine：对命令进行解析
    • Native Interface：融合不同开发语言的原生库为 Java 所用
    • Rumtime Data Area：JVM 内存空间结构模型
  • 类从编译到执行的过程(假设类名为 Robot)
    • 编译器将 Robot.java 源码编译为 Robot.class 字节码文件
    • ClassLoader 将字节码转换为 JVM 中的 Class 对象
    • JVM 利用 Class 对象 实例化 Robot 对象
  • 内存模型：
    • 从操作系统角度来看：内存可以划分为内核空间和用户空间，其中用户空间是 Java 进行运行时的内存空间
    • 从线程方面来看：线程私有的区域有：程序计数器、虚拟机栈、本地方法栈；所有线程共享的区域有 MetaSpace 和堆
    • 程序计数器(Program Counter Register)是对 Java 代码计数，对 Native 方法则计数器值为 Undefined；是当前线程所执行的线程代码逻辑上(非物理)的行号指示器，不会发生内存泄露。
    • 其中虚拟机栈包含多个栈帧，每个栈帧包括局部变量表、操作数栈、动态链接、返回地址。
    • 递归过深会导致栈帧数量超过虚拟机栈的深度，引发 StackOverFlow
    • 当虚拟机栈可以动态扩展时，如果无法申请到足够的内存，会引起 OutOfMemory
    • 当方法调用结束后，栈帧的内存就会被回收，不用通过 GC 来回收
    • MetaSpace 和 PermGen 都是方法区的一种实现。在 Java8 之后使用 MetaSpace 替代了 PermGen。
      • 元空间使用本地内存，而 永久代使用的是 JVM 的内存。因此不再会出现 OutOfMemory 异常
      • 字符串常量池存放在永久代中，容易出现性能问题和内存溢出
      • 类和方法的信息大小难以确定给永久代大小的指定带来困难；如果指定太小会可能会溢出，如果太大，则老年代可能会溢出
      • 永久代会为 GC 带来不必要的复杂性，元数据可能会随着 FULL GC 发生移动。使用 MetaSpace 可以更好支持并发隔离元数据
      • 永久代是 HotSpot 特有的处理，而其他虚拟机并不支持永久代。所以使用 MetaSpace 可以方便 HotSpot 与其他 JVM 比如 Jrockit 的集成
      • 字符串常量池在 JDK7 之前是放在永久代中的，在 JDK7 之后被移动到了堆中

常问面试题：

  • JVM 三大性能调优参数 -Xms -Xmx -Xss 的含义

    • -Xss：规定了每个线程虚拟机栈的大小，决定了进程中的并发线程数
    • -Xms：堆的初始值
    • -Xmx：堆的最大值
    • 一般把 -Xms 和 -Xmx 设置为一样，因为堆不够用而进行扩容时会发生内存抖动，影响稳定性

  • Java 内存模型中堆和栈的区别--内存分配策略

    • 静态存储：编译时确定每个数据目标在运行时的存储空间要求，要求不能有嵌套递归和可变数据结构的存在
    • 栈式存储：数据区需求在编译时未知，在运行时模块入口前确定其大小并分配内存
    • 堆式存储：编译时或者运行时模块入口都无法确定，动态分配(比如可变长度串和对象实例)，可以按照任意方式释放和分配
    • 管理方式：栈内存自动释放，堆释放内存需要 GC
    • 空间大小：栈比堆小
    • 碎片相关：栈产生而碎片远小于堆
    • 分配方式：栈支持静态和动态分配，堆仅支持动态分配
    • 效率：栈的效率比堆高，因为栈是先进后出的，只有入栈和出栈两个操作，管理简单，但是灵活程度不够。
    • 从一个例子来看 元空间、堆、栈的区别 
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      public class HelloWorld {
          private String name;

          public void sayHello() {
              System.out.println("Hello " + name);
          }

          public void setName(String name) {
              this.name = name;
          }

          public static void main(String[] args) {
              int a = 1;
              HelloWorld hw = new HelloWorld();
              hw.setName("test");
              hw.sayHello();
          }
      }
      上述代码对应的内存分配如下：
    内存区域 存储内容
    元空间 Class:HelloWorld-Method:sayHello-Field:name
    Class:system
    堆 Object:String("test")
    HelloWorld
    栈 指向对中字符串对象(Parameter referene:test)和本地变量对象(Variable referene:hw)的引用，局部变量表(a)，行号
    • 不同 JDK 版本之间 intern() 方法的区别：
      • JDK6 以及之前：调用 intern 方法时，如果字符串常量池已经包含有该字符串对象，则从字符串常量池中返回该字符串对象的引用；否则将此字符串对象添加到字符串常量池中，再返回该字符串对象的引用。
      • JDK6 之后：调用 intern 方法时，如果字符串常量池已经包含有该字符串对象，则从字符串常量池中返回该字符串对象的引用；否则如果该字符串对象已经存在于堆中，则将堆中此字符串对象的引用添加到字符串常量池中，并且返回该引用；如果堆中不存在，则在字符串常量池中创建该字符串并返回其引用。
      • 总结：在 JDK6 之前，只能把堆中字符串的副本复制到字符串常量池中，而在 JDK6 之后，可以把堆中字符串对象的引用放到字符串常量池中
    • 在 Java7 之后，常量池(包括字面量和符号引用量)已经从永久代移动到堆中。因为之前字符串常量池在永久代中，如果频繁使用 intern 方法创建字符串，会导致 OOM(可以使用 -XX:PermSize 和 -XX:MaxPermSize 来指定永久代的大小)。

  • 关于 intern 方法在 JDK6 前后的区别，我们通过一个例子来看： 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class InternDifference {
        public static void main(String[] args) {
            String s1=new String("a");
            s1.intern();
            String s2="a";
            System.out.println(s1==s2);

            String s3=new String("a")+new String("a");
            s3.intern();
            String s4="aa";
            System.out.println(s3==s4);
        }
    上述代码在 JDK6 的输出是： 
    1
    2
    false
    false
    在 JDK7 的输出是： 
    1
    2
    false
    true
    解释：

  • String s1 = new String("1"); 第一句代码，生成了2个对象。常量池中的“1” 和堆中的字符串对象。s.intern(); 这一句是 s1 对象去常量池中寻找后发现 “1” 已经在常量池里了，因此 s1 指向的地址还是堆中的字符串对象。

  • 接下来String s2 = "1"; 这句代码是生成一个 s2的引用指向常量池中的“1”对象。 结果就是 s1 和 s2 的引用地址明显不同

  • String s3 = new String("1") + new String("1");，这句代码中现在生成了2最终个对象，是字符串常量池中的“1” 和 JAVA Heap 中的 s3引用指向的对象。中间还有2个匿名的new String("1")我们不去讨论它们。此时s3引用对象内容是”11”，但此时常量池中是没有 “11”对象的。

  • 接下来s3.intern();这一句代码

    • 在JDK6以前是直接把字符串对象的值存储在字符串常量池中，所以把 s3 中的“11”字符串放入 String 常量池中，因为此时常量池中不存在“11”字符串`，所以可以在常量池中生成一个 “11” 的对象。而 s3 指向的地址还是堆中字符串对象“11”的地址
    • 而 JDK6 之后常量池中不需要再存储一份对象了，可以直接存储堆中的引用，所以将堆中字符串对象的地址放在字符串常量池中，所以 s3 指向的地址就是字符串常量池中的地址。

  • 最后String s4 = "11"; 这句代码中”11”是显示声明的，因此会直接去常量池中创建，创建的时候发现已经有这个对象了

    • 在 JDK6 中，字符串常量池中存储的是一个”11”字符串对象，而 s3 指向的是堆中存放的字符串对象，与字符串常量池中的字符串没有关系，因此最后的比较 s3 == s4 是 false。
    • 在 JDK 7 中，字符串常量池中存储的是是指向 s3 引用对象的一个引用。所以 s4 引用就指向和 s3 一样了。因此最后的比较 s3 == s4 是 true。

  • 下面是上述代码在内存区域中的图示：

    JDK6 内存示意图


    JDK7 内存示意图


    参考链接

  • 美团技术团队：深入解析String#intern

喜欢这篇文章？打赏一下作者吧

评论

我的微信公众号
公众号GithubCSDN知乎

链接

分类

最新文章

归档

标签

AI58
CentOS1
Deep Learning58
GNN2
ICCV1
Paper3
SQL3
×