首页 / JAVA / JAVA-类加载（类的生命周期）

JAVA-类加载（类的生命周期）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JAVA-类加载（类的生命周期），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6764字，纯文字阅读大概需要10分钟。

内容图文

类从被加载到虚拟机内存开始，到卸载出内存为止。

JAVA-类加载（类的生命周期） - 文章图片

解析阶段在某些情况下可以在初始化后再开始，这是为了支持 Java 语言的运行时绑定。

 

一、类加载时机

JVM 规范没有强制约束类加载过程的第一阶段（加载）什么时候开始，但对于“初始化”阶段，有着严格的规定。

 

1.1.有且仅有 5 种情况必须立即对类进行“初始化”：

1.在遇到 new、putstatic、getstatic、invokestatic 字节码指令时，如果类尚未初始化，则需要先触发其初始化。
2.对类进行反射调用时，如果类还没有初始化，则需要先触发其初始化。
3.初始化一个类时，如果其父类还没有初始化，则需要先初始化父类。
4.虚拟机启动时，用于需要指定一个包含 main() 方法的主类，虚拟机会先初始化这个主类。
5.当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic、REF_putStatic、REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类还没初始化，则需要先触发其初始化。

这 5 种场景中的行为称为对一个类进行主动引用，除此之外，其它所有引用类的方式都不会触发初始化，称为被动引用。

 

1.2.几种被动引用：

1.通过子类引用父类的静态字段，不会导致子类初始化。对于静态字段，只有直接定义这个字段的类才会被初始化。

JAVA-类加载（类的生命周期） - 文章图片JAVA-类加载（类的生命周期） - 文章图片 
class SuperClass {
    static {
        System.out.println("SuperClass init!");
    }
    public static int value = 123;
}

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

public class NotInitialization {
    public static void main(String[] args) {
        System.out.println(SubClass.value);
        // SuperClass init!
    }
}
View Code

2.通过数组定义来引用类，不会触发此类的初始化。

JAVA-类加载（类的生命周期） - 文章图片JAVA-类加载（类的生命周期） - 文章图片 
class SuperClass2 {
    static {
        System.out.println("SuperClass init!");
    }
    public static int value = 123;
}

public class NotInitialization2 {
    public static void main(String[] args) {
        SuperClass2[] superClasses = new SuperClass2[10];
    }
}
View Code

3.常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

JAVA-类加载（类的生命周期） - 文章图片JAVA-类加载（类的生命周期） - 文章图片 
class ConstClass {
    static {
        System.out.println("ConstClass init!");
    }

    public static final String HELLO_BINGO = "Hello Bingo";
}

public class NotInitialization3 {
    public static void main(String[] args) {
        System.out.println(ConstClass.HELLO_BINGO);
    }
}
View Code

编译通过之后，常量存储到 NotInitialization 类的常量池中，NotInitialization 的 Class 文件中并没有 ConstClass 类的符号引用入口，这两个类在编译成 Class 之后就没有任何联系了。

 

1.3.关于接口加载

当一个类在初始化时，要求其父类全部都已经初始化过了，但是一个接口在初始化时，并不要求其父接口全部都完成了初始化，当真正用到父接口的时候才会初始化。

 

 

二、类的加载过程

 2.1.加载

JVM 需要完成 3 件事：

1.通过类的全限定名获取该类的二进制字节流。
2.将二进制字节流所代表的静态结构转化为方法区的运行时数据结构。
3.在内存中创建一个代表该类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口。

怎样获取类的二进制字节流，JVM 没有限制。除了从编译好的 .class 文件中读取，还有以下几种方式：

从 zip 包中读取，如 jar、war 等
从网络中获取
通过动态代理生成代理类的二进制字节流
从数据库中读取
。。。

数组类本身不通过类加载器创建，由 JVM 直接创建，再由类加载器创建数组中的元素类。

加载阶段与连接阶段的部分内容交叉进行，但这两个阶段的开始仍然保持先后顺序。

 

2.2.验证

确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

 

2.3.准备

为类变量（静态成员变量）分配内存并设置初始值的阶段。这些变量（不包括实例变量）所使用的内存都在方法区中进行分配。

基本类型初始值（JDK8）https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.12.5

对于 byte 类型，默认值为零，即（byte）0。
对于 short 类型，默认值为零，即（short）0。
对于 int 类型，默认值为零，即 0。
对于 long 类型，默认值为零，即 0L。
对于 float 类型，默认值为正零，即 0.0f。
对于 double 类型，默认值为正零，即 0.0d。
对于 char 类型，默认值为空字符，即 '\u0000'。
对于 boolean 类型，默认值为 false。
对于所有引用类型，默认值为 null。

存在特殊情况 https://www.jianshu.com/p/520295a63967

/**
 * 准备阶段过后的初始值为 0 而不是 123，这时候尚未开始执行任何 Java 方法
 */
public static int value = 123;

/**
 * 同时使用final 、static来修饰的变量（常量），并且这个变量的数据类型是基本类型或者String类型，就生成ConstantValue属性来进行初始化。
 * 没有final修饰或者并非基本类型及String类型，则选择在<clinit>方法中进行初始化。
 * 准备阶段虚拟机会根据 ConstantValue 的设置将 value 赋值为 123
 */
public static final int value = 123;

 

2.4.解析

虚拟机将常量池内的符号引用替换为直接引用。

https://www.cnblogs.com/shinubi/articles/6116993.html

符号引用：一个 java 文件会编译成一个class文件。在编译时，java 类并不知道所引用的类的实际地址，因此只能使用符号引用来代替。

直接引用：直接指向目标的指针（指向方法区，Class 对象）、指向相对偏移量（指向堆区，Class 实例对象）或指向能间接定位到目标的句柄。

 

2.5.初始化

类加载过程的最后一步，是执行类构造器 <clinit>() 方法的过程。

<init>()  与 <clinit>() 介绍：  https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.9

https://blog.csdn.net/u013309870/article/details/72975536

<init>()：为 Class 类实例构造器，对非静态变量解析初始化，一个类构造器对应个。

<clinit>()：为 Class 类构造器对静态变量，静态代码块进行初始化，通常一个类对应一个，不带参数，且是 void 返回。当一个类没有静态语句块，也没有对类变量的赋值操作，那么编译器可以不为这个类生成 <clinit>() 方法

加载顺序：

<clinit>() 方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static {} 块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的。

静态语句块中只能访问定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块中可以赋值，但不能访问。

static {
    i = 0;  // 给后面的变量赋值，可以正常编译通过
    System.out.println(i);  // 使用后面的变量，编译器会提示“非法向前引用”
}
static int i = 1;

虚拟机会保证在子类的 <clinit>() 方法执行之前，父类的 <clinit>() 方法已经执行完毕。

由于父类的 <clinit>() 方法先执行，意味着父类中定义的静态语句块要优先于子类的变量赋值操作。

static class Parent {
    static {
        A = 2;
    }
    public static int A = 1;
}

static class Sub extends Parent {
    public static int B = A;
}

public static void main(String[] args) {
    System.out.println(Sub.B);  // 输出 1
}

来看一个加载顺序的问题

public static JvmTest jt = new JvmTest();

public static int a;
public static int b = 0;

static {
    a++;
    b++;
}

public JvmTest() {
    a++;
    b++;
}

public static void main(String[] args) {
    /**
     * 准备阶段：为 jt、a、b 分配内存并赋初始值 jt=null、a=0、b=0
     * 解析阶段：将 jt 指向内存中的地址
     * 初始化：jt 代码位置在最前面，这时候 a=1、b=1
     *          a 没有默认值，不执行，a还是1，b 有默认值，b赋值为0
     *          静态块过后，a=2、b=1
     */
    System.out.println(a);  // 输出 2
    System.out.println(b);  // 输出 1
}

关于接口初始化：

接口中不能使用静态代码块，但接口也需要通过 <clinit>() 方法为接口中定义的静态成员变量显式初始化。

接口与类不同，接口的 <clinit>() 方法不需要先执行父类的 <clinit>() 方法，只有当父接口中定义的变量被使用时，父接口才会初始化。

 

虚拟机会保证一个类的 <clinit>() 方法在多线程环境中被正确加锁、同步。如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 <clinit>() 方法。

https://github.com/doocs/jvm/blob/master/docs/08-load-class-time.md

https://github.com/doocs/jvm/blob/master/docs/09-load-class-process.md

内容总结

以上是互联网集市为您收集整理的JAVA-类加载（类的生命周期）全部内容，希望文章能够帮你解决JAVA-类加载（类的生命周期）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/821934.html

来源：【匿名】