1、JDK，JRE以及JVM的关系

JDK全称为Java Development Kit，是Java开发人员在编写Java程序时使用的开发工具包。如图所示，其包括了JRE和JVM。
其中JRE是Java程序的运行环境，提供了JVM的实现和一些基本类库。
而JVM则是识别.class文件中的指令并调用操作系统完成指令动作。

2、编译器到底干了什么事？

仅仅是将我们的 .java 文件转换成了 .class 文件，实际上就是文件格式的转换。

3、类加载机制是什么？

所谓类加载机制就是：虚拟机把Class文件加载到内存，并对数据进行校验、转换解析和初始化等操作，形成虚拟机可以直接使用的Java类型，即java.lang.Class 。具体为以下几个步骤：

3.1、装载(Load)

装载的操作其实就是查找和导入class文件

1. 通过一个类的全限定名获取定义此类的二进制字节流（全限定名是将类名中的.替换为/，例如 java/lang.String）
2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
3. 在Java堆中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口

3.2、链接(Link)

• 验证(Verify)：保证被加载类的正确性

1. 文件格式验证
2. 元数据验证
3. 字节码验证
4. 符号引用验证

• 准备(Prepare)：为类的静态变量分配内存，并将其初始化为默认值

  public class Demo1 {
  private static int i;
  
  public static void main(String[] args) {
      // 正常打印出0，因为静态变量i在准备阶段会有默认值0
      System.out.println(i);
  }
  }
  

  public class Demo2 {
      public static void main(String[] args) {
          // 编译通不过，因为局部变量没有赋值不能被使用
          int i;
          System.out.println(i);
      }
  }
  

• 解析(Resolve)：把类中的符号引用转换为直接引用的过程
  主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用限定符7类符号引用进行。

符号引用就是一组符号来描述目标
直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄

3.3、初始化(Initialize)

对类的静态变量，静态代码块执行初始化操作

4、类加载器有哪些？

在装载(Load)阶段，其中第(1)步:通过一个类的全限定名获取定义此类的二进制字节流，需要借助类装载器完成，顾名思义，就是用来装载Class文件的。

1. Bootstrap ClassLoader 负责加载 JAVA_HOME中 jre/lib/rt.jar 里所有的class或Xbootclassoath选项指定的jar包。由C++实现，不是ClassLoader子类。
2. Extension ClassLoader 负责加载java平台中扩展功能的一些jar包，包括`$$JAVA_HOME中jre/lib/*.jar 或 -Djava.ext.dirs指定目录下的jar包。
3. App ClassLoader 负责加载classpath中指定的jar包及Djava.class.path所指定目录下的类和jar包。
4. Custom ClassLoader 通过java.lang.ClassLoader的子类自定义加载class，属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader。

5、什么是双亲委派机制？

双亲委派是指在加载类的时候，如上图，按照类加载器的顺序向上检查该类是否加载过，向下委派是否可以加载该类。 避免类重复加载并且保证安全性。其执行过程如下图

类加载源码

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }

6、介绍一下JVM内存划分（运行时数据区）

6.1、方法区

方法区是各个线程共享的内存区域，在虚拟机启动时创建。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却又一个别名叫做Non-Heap(非堆)，目的是与Java堆区分开来
用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常

注意：JVM运行时数据区是一种规范，在JDK 8中的实现就是Metaspace，在JDK6或7中的实现就是Perm Space

6.2、Heap(堆)

Java堆是Java虚拟机所管理内存中最大的一块，在虚拟机启动时创建，被所有线程共享。
Java对象实例以及数组都在堆上分配。

6.3、Java Virtual Machine Stacks(虚拟机栈)

虚拟机栈是一个线程执行的区域，保存着一个线程中方法的调用状态。所以虚拟机栈是线程私有的，随着线程的创建而创建。
每一个被线程执行的方法，为该栈中的栈帧，即每个方法对应一个栈帧。（调用一个方法，就会向栈中压入一个栈帧；一个方法调用完成，就会把该栈帧从栈中弹出。）
每个栈帧中包括局部变量表(Local Variables)、操作数栈(Operand Stack)、动态链接、方法返回地址和附加信息。

• 局部变量表：方法中定义的局部变量以及方法的参数存放在这张表中。如需要使用的话，必须通过相关指令将其加载至操作数栈中作为操作数使用。
• 操作数栈：以压栈和出栈的方式存储操作数的
• 动态链接：符号引用转换为直接引用

7、堆为什么进行分代设计？

如下图，堆被分为Young区、Old区，其中Young区又分为Eden区、Survivor区，而Survivor区又分为S0和S1。

为什么这样设计有以下原因：

1. 如果堆没有分代，等到堆空间满了进行清理时，需要消耗很长的时间去清理，期间应用也无法运行。
2. 因为大多数对象生存时间是很短的（大多对象都是执行完方法后就没用了），需要及时被清理，但是又不能清理整个堆，所以划分了Young区、Old区，这样对象生存时间短的放到Young区，生存时间长的放到Old区，每次只清理Young区，提高效率。
3. 此时如果来了一个新对象，并且Young区空间足以装下新的对象，但是因为Young区反复被清理过几次，内存空间不连续，没有完整的空间装下新对象，就会造成空间浪费。
4. 这个时候如果有另外一个区域可以存放Young区的4个存活对象时（此时放入Old区只会加快清理的次数），新对象就可以正常放进来，所以有了Eden区、Survivor区。
5. 但是只有一个Survivor区也会存在内存碎片问题，所以Survivor区分为S0和S1，当Young GC时，将Eden区和其中一个S区的对象都迁移到另一个S区，从而解决内存碎片的问题。
   

8、老年代的担保机制

当有一个新的对象Young区无法分配空间时，直接放到老年代。

9、为什么Eden：S0：S1 是8：1：1

1. 大多数对象生存时间是很短的，并且在Eden就可能会被清理掉
2. S0和S1需要来回存放对方以及Eden区的对象，所以比例需要一致

10、对象的创建以及分配过程

11、方法区、元数据区、持久代是什么关系？

方法区可以看作是一个规范，JDK1.7之前的实现是持久代，JDK1.8以及其之后的实现是元数据区。

元数据区的优势是，如果本机内存为16G尽管只给JVM分配了4G，元数据区也是会用到本机的其他12G内存，这样的好处是我们不用估算类信息、常量、静态变量这些数据的占用空间。

如下图，方法区中的静态变量、常量在运行时内存中，而类信息在直接内存中。

12、对象在内存中的布局