您的位置: 首页  >  文章  >  JVM6：虚拟机类加载机制

JVM6：虚拟机类加载机制

分类: 文章 • 2025-01-31 21:33:34

文章目录

类加载时机

类从被加载到虚拟机内存中开始，到卸载出内存为止，整个生命周期包括：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）及卸载（Unloading）。其中，验证、准备和解析3个部分统称为连接（Linking）。如图所示：
JVM6：虚拟机类加载机制

加载、验证、准备、初始化和卸载这5个生命周期部分，是需要按顺序开始。解析由于Java支持动态绑定的缘故，所以不一定，有可能在初始化之后再开始。

在虚拟机规范中，并没有规定加载阶段何时开始；而是规范了以下5种情况时必须得完成初始化：

  1. 遇到new、getstatic、putstatic和invokedynamic4个指令时；
  2. 使用java.lang.reflect包的方法对类进行反射调用时；
  3. 当初始化一个类时，若父类没有初始化，则需初始化父类；
  4. 虚拟机启动时，用户指定要执行的主类（包含main()方法的那个类），需要初始化该主类；
  5. 使用JDK1.7动态语言支持时，如果java.lang.invoke.MethodHandle实例最后的解析结果是REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄且该句柄对应的类没有初始化，则需要初始化

以上5种情形，都会触发类的初始化，称为主动引用；除此之外，还会有以下3种方式并不会触发类的初始化，称为被动引用：

  1. 通过子类引用父类的静态字段，不会导致子类的初始化；
public class SuperClass {

  static {
    System.out.println("SuperClass init!");
  }

  public static int value = 123;

  public static final String HELLOWORLD = "Hello World!!";
}

public class SubClass extends SuperClass {

  static {
    System.out.println("SubClass init!");
  }

}

//输出SuperClass init!
public class NotInitializationDemo1 {

  public static void main(String[] args) {
    System.out.println(SubClass.value);
  }

}
  1. 通过数组定义来引用类，不会触发此类的初始化；
public class SuperClass {

  static {
    System.out.println("SuperClass init!");
  }

  public static int value = 123;
}

public class NotInitializationDemo2 {

  public static void main(String[] args) {
    SuperClass[] superClasses = new SuperClass[10];
  }

}
  1. 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，也不会触发定义常量的类的初始化
public class NotInitializationDemo3 {

  public static void main(String[] args) {
    System.out.println(SuperClass.HELLOWORLD);
  }

}

类加载过程

加载

在加载阶段，需要完成3件事情：

  1. 通过类的全限定名来获取定义此类的二进制字节流；注意：此处并没有说从哪里获取二进制流，可以从ZIP包、网络或者运行时自动计算生成等；
  2. 将二进制字节流所代表的静态存储结构转为方法区的运行时数据；
  3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口

验证

确保Class文件的字节流中包含的信息符合当前虚拟机的要求，且不会危害虚拟机自身的安全。
验证阶段大致完成4类验证：

  1. 文件格式验证-是否符合Class文件格式的规范

    1. 文件是否已0xCAFEBABE开头；
    2. 主次版本号是否在虚拟机支持范围内；
    3. 常量池的常量中是否有不被支持的常量类型（检查常量tag标志）；
    4. 指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量；
    5. CONSTANT_Utf8_info型的常量中是否有不符合UTF8编码的数据；
      …

  2. 元数据验证-是否符合Java语言规范的要求；

    1. 这个类是否有父类，除了java.lang.Object之外；
    2. 这个类的父类是否继承了不允许被继承的类
    3. 如果此类不是抽象类，是否实现了父类或接口中要实现的所有方法；
      …

  3. 字节码验证-通过数据流和控制流，确认程序语义是合法的

    1. 保证跳转指令不会跳转到方法体以外的字节码指令上；
      …

  4. 符号引用验证-对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验

    1. 符号引用中通过字符串描述的全限定名是否能找到对应的类；
    2. 在指定类中是否存在符合方法的字段描述符及简单名称所描述的方法和字段；
    3. 符号引用中的类、字段、方法的访问性是否可被当前类访问；
      …

准备

为类变量分配内存，并设置类变量的初始值。此处的初始值，是指数据类型的零值，而非用户程序定义的值。各类型的初始值如下：

数据类型 零值
int 0
long 0L
short (short)0
char '\u0000\'
byte (byte)0
boolean false
float 0.0f
double 0.0d
reference

注意：如果类字段属性表中存在ConstantValue属性，那在准备阶段变量会被初始化为ConstantValue属性所指定的值。如public static final int value = 123;

解析

解析是将常量池内的符号引用替换为直接引用的过程。JVM规范未规定解析阶段发生的时间，只要求在执行anewarray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invokespecial、invokestatic、invokevirtual、ldc、ldc_w、multianewarray、new、putfield及putstatic这16个用于操作符号引用的字节码指令前，先对它们所使用的符号引用进行解析。

初始化

初始化是执行类构造器<clinit>()方法的过程。

  1. <clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在其之后的变量，在前面的静态语句块可以赋值，但不能被访问。如：
public class StaticBlockVarTest {

  static {
    i = 0;
    //System.out.println(i);  //非法向前访问
  }

  static int i = 1;

}
  1. <clinit>()方法与类的构造函数（即init()）方法不同，它不需要显式地调用父类构造器，虚拟机会保证在子类的<clinit>()方法执行之前，父类的<clinit>()方法已经执行完毕。
  2. 由于父类的<clinit>()方法先执行，意味着父类中定义的静态语句块要优于子类的变量赋值操作。如：
public class CInitTest {

  public static int A = 1;

  static {
    A = 2;
  }

  static  class CInitSub extends CInitTest {
    public static int B = A;
  }

  public static void main(String[] args) {
    System.out.println(CInitSub.B);
  }

}
  1. <clinit>()方法对于类或接口来说并不是必需的。如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生成<clinit>()方法。
  2. 接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成<clinit>()方法。但接口与类不同，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的<clinit>()方法。
  3. 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步。如果多个线程去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞，直到活动线程执行完毕之后唤醒，但是其他线程不会再进入<clinit>()方法。同一个类加载器下，一个类只会被加载一次。

描述类的实例化顺序，比如父类静态数据、构造函数、字段、子类静态数据、构造函数、字段，当new的时候，他们的执行顺序

class Parent {

  private static int pa = 1;
  private static int pb;
  private int pc = initPc();

  static {
    System.out.println("1. Parent静态代码块");
    pb = 1;
    System.out.println("1. Parent静态代码块为pb赋值");
  }

  int initPc() {
    System.out.println("3. Parent实例化属性pc");
    return 3;
  }

  public Parent() {
    System.out.println("4. Parent构造函数");
  }
}

class Sub extends Parent {

  private static int sa = 11;
  private static int sb;

  private int sc = initSc();

  private int initSc() {
    System.out.println("5. Sub 实例化属性sc");
    return 0;
  }

  static {
    System.out.println("2. Sub 静态代码块");
    sb = 12;
    System.out.println("2. Sub 静态代码块为sb赋值");
  }

  public Sub() {
    System.out.println("6. Sub 构造函数");
  }
}

public class App {

  /** 数据结果：
   * 1. Parent静态代码块
   * 1. Parent静态代码块为pb赋值
   * 2. Sub 静态代码块
   * 2. Sub 静态代码块为sb赋值
   * 3. Parent实例化属性pc
   * 4. Parent构造函数
   * 5. Sub 实例化属性sc
   * 6. Sub 构造函数
   */
  public static void main(String[] args) {
    Sub sub = new Sub();
  }
}

结果：

  • Parent静态属性
  • Parent静态代码块
  • Sub静态属性
  • Sub静态代码块
  • Parent实例属性
  • Parent构造函数
  • Sub实例属性
  • Sub构造函数

类加载器

双亲委派模型

绝大部分Java程序使用以下3种系统提供的类加载器：

  1. 启动类加载器（Bootstrap ClassLoader）

    负责加载<JAVA_HOME>\lib目录中，或者被-Xbootclasspath参数所指定的路径中的，并且是虚拟机识别的类库加载到虚拟机内存中

  2. 扩展类加载器（Extension ClassLoader）

    此类加载器由sun.misc.Launcher$ExtClassLoader实现，负责加载<JAVA_HOME>\lib\ext目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库

  3. 应用程序类加载器（Application ClassLoader）

    此类加载器由sun.misc.Launcher$AppClassLoader实现，负责加载用户类路径（ClassPath）上所指定的类库

如若还有必要，可以加入自定义的类加载器。这些加载器之间的关系一般如图所示：
JVM6：虚拟机类加载机制

上图展示的类加载器之间的层次关系成为类加载器的双亲委派模型。其工作过程：如果一个类加载器收到了类加载的请求，首先不会自己去加载这个类，而是把这个请求委派给父类加载器去完成，每个层次的类加载器都是如此，因此所有的加载请求最终都传到启动类加载器中，只有当父加载器无法加载对应的请求时，子加载器才会尝试去加载。

自定义类加载器

自定义类加载器只需要继承java.lang.ClassLoader类，重写findClass()方法：

/**
 * 自定义类加载器.
 */
public class CustomClassLoaderDemo extends ClassLoader {

  private String rootPath;

  public CustomClassLoaderDemo(String rootPath) {
    this.rootPath = rootPath;
  }

  @Override
  protected Class<?> findClass(String s) throws ClassNotFoundException {
    try {
      byte[] classData = loadClassData(s);
      return this.defineClass(s, classData, 0, classData.length);
    } catch (IOException e) {
      e.printStackTrace();
    }

    return null;
  }

  private byte[] loadClassData(String s) throws IOException {
    String s1 = s.replace('.', '\\');
    String classFile = rootPath + File.separatorChar + s1 + ".class";
    FileInputStream fis = new FileInputStream(classFile);

    byte[] classData = new byte[fis.available()];
    fis.read(classData);

    return classData;
  }
}

参考个案例分析：http://blog.****.net/u013256816/article/details/50837863

相关推荐