jvm(一)之类加载与初始化

最新推荐文章于 2022-04-25 20:21:38 发布
最新推荐文章于 2022-04-25 20:21:38 发布
阅读量331 收藏 1
点赞数
分类专栏： # jvm 文章标签： jvm classloader 初始化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usagoole/article/details/89810805
版权

文章目录

类加载过程

  1. 类从被加载到JVM内存中，一直到卸载出内存，整个生命周期包括

    • 加载(Loading):类加载器读取二进制流程到JVM内部，并存储在方法区(或者元数据空间)内。并且转换成一个与目标类型对应的java.lang.Class对象实例。

    • 连接(Linking)阶段:

      • 验证(Verification):(1)验证字节码文件是否符合JVM规范，如果不是一个有效的字节码文件，会抛出java.lang.VerifyError异常。(2)验证字节码信息是否符合java语法规则 (3)操作验证:对类型的方法执行验证，确保一个类的方法在执行时，不会对jvm产生不良的影响
      • 准备(Preparation):静态变量分配内存空间，并设置默认初始值
      • 解析(Resolution):将字节码常量池中的符号引用全部转换为直接引用，包括类、接口、方法和字段的符号引用。解析阶段在初始化后执行

    • 初始化(Initiazation):执行所有static修饰的代码，包括变量和代码块。如果是静态变量，使用用户指定的值覆盖默认的值。如果是静态代码块，则按照顺序依次执行所有静态代码块里的所有操作。所有的类变量初始化语句和静态代码块都会在java源码执行字节码编译时，被编译器放在收集器里，存在一个叫做<clinit>()方法，此方法可以被称为类初始化方法。对于接口来说就是接口初始化方法。

      class init.StaticParent {
  static int a;

  init.StaticParent();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  static void println();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String parent println
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  static {};
    Code:
       0: bipush        20
       2: putstatic     #5                  // Field a:I
       5: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       8: ldc           #6                  // String parent static block
      10: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      13: return
}

static {}就是<clinit>()，javac编译器将其名字进行了修改。

    • 使用

    • 卸载:Class的卸载是不可控的。JVM中的Class只有满足以下三个条件，才能被GC回收，也就是该Class被卸载.

      • 该类所有的实例都已经被GC。
      • 加载该类的ClassLoader实例已经被GC。
      • 该类的java.lang.Class对象没有在任何地方被引用。

  2. 有JVM自带的类加载器(根、扩展、系统)所加载的类，在JVM的生命周期中，始终不会被卸载。jvm会始终引用自带的类加载器，这些类加载器也会始终引用它们所加载的类的Class对象。

初始化

  1. JVM规范明确规定了类的初始化时机，即一个类或者接口应该在首次主动使用时执行初始化操作。主动使用包括以下情况

    • 为一个类创建一个新的对象实例时(new、反射、序列化)
    • 调用一个类型的静态方法(在字节码中执行invokestatic指令)
    • 调用一个类型或接口的静态字段或者对这些静态字段执行赋值操作(字节码中执行getstatic或者putstatic)，对于final修饰的常量表达式除外(编译阶段即可确认值的表达式)
    • 调用java的反射方法(调用java.lang.Class中的方法或者java.lang.reflect包中类的方法)
    • 初始化一个类的派生类(子类初始化必须所有父类先完成初始化)
    • 直接运行一个main函数入口的类
    • jdk7提供的动态语言支持:java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化，则执行初始化

  2. 一个类在初始化之前必须要求它的所有超类都完成初始化操作。但是对于接口而言，此规则不适用。只有在某个接口中声明的非常量字段被使用时，该接口才会被初始化，而不会因为实现这个接口的派生接口或派生类要初始化而被初始化。

  3. 如果一个类拥有超类，如果超类还没有被执行初始化，优先对超类初始化，但是在<clinit>()方法内部不会显式调用超类<clinit>()方法，会由JVM负责保证在一个类的<clinit>()方法执行之前，它的超类<clinit>()方法已经被执行。

  4. JVM必须保证一个类在被初始化的过程中，如果有多个线程同时初始化它，仅仅只能允许其中一个线程对其进行初始化操作，而其余线程必须等待。

  5. 如果一个类中并没有声明任何的类变量，也没有静态代码块，那么这个类在编译为字节码后，字节码文件中将不会包含<clinit>()方法。如果一个类中声明了静态变量，但是没有明确使用类变量的初始化语句以及静态代码块来执行初始化操作，编译的字节码文件中也不包含<clinit>()方法

类中常量的初始化

  1. 验证常量的初始化

    /**
 * 1. 增加jvm参数
 * -XX:+TraceClassLoading   跟踪类的加载(包括动态生成的类的加载)
 * -XX:+TraceClassUnloading 跟踪类的卸载(包括动态生成的类的卸载)
 */
public class ConstantTest {
    public static void main(String[] args) {
        System.out.println(Parent.msg);
    }
}

class Parent {
    public static final String msg = "I am parent init.constant";

    static {
        System.out.println("I am parent static block");
    }
}

    输出可以看出，Parent类并没有加载,即此时删除编译后的Parent.class文件也不会影响ConstantTest.class的执行

    ...省略...
[Loaded init.ConstantTest from file:/Volumes/O/java-classloader/out/production/classes/]
...省略...
I am parent init.constant
...省略...

    查看字节码文件，ldc 表示将int，float或String类型的常量值从常量池中推送至栈顶。

    $ javap -c ConstantTest
Compiled from "ConstantTest.java"
public class ConstantTest {
  public ConstantTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #4                  // String I am parent init.constant
       5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}
    • 常量(确定的)在编译阶段(Parent的msg常量)会存入到调用这个常量的方法所在类的常量池(ConstantTest类的常量池)中
    • 对于以上程序，调用类并没有直接引用到定义常量的类，因此不会触发定义常量类的初始化
    • 对于以上程序，Parent的msg常量值会存放到ConstantTest类的常量池中，之后ConstantTest与Parent就没有任何关系了

  2. 验证在编译阶段无法确认常量值的情况

    /**
 * 1. 增加jvm参数
 * -XX:+TraceClassLoading   跟踪类的加载(包括动态生成的类的加载)
 * -XX:+TraceClassUnloading 跟踪类的卸载(包括动态生成的类的卸载)
 */
public class ConstantTest {
    public static void main(String[] args) {
        System.out.println(Parent.msg);
    }
}

class Parent {
    //public static final String msg = "I am parent init.constant";
    public static final String msg = UUID.randomUUID().toString();

    static {
        System.out.println("I am parent static block");
    }
}

    输出可以看出,如果一个常量在编译期间不能确认值，即不会放到调用类的常量池中，此时运行会导致主动使用拥有此常量的类(Parent被加载并且被初始化了)

    ...省略...
[Loaded init.ConstantTest from file:/Volumes/O/java-classloader/out/production/classes/]
[Loaded init.Parent from file:/Volumes/O/java-classloader/out/production/classes/]

I am parent static block
e2f1daa2-615a-4d9d-9037-9115732dce02

...省略...

    查看字节码,执行的指令是getstatic

    $ javap -c ConstantTest
Compiled from "ConstantTest.java"
public class init.ConstantTest {
  public init.ConstantTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: getstatic     #3                  // Field init/Parent.msg:Ljava/lang/String;
       6: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       9: return
}

静态变量的初始化

  1. 静态变量的主动使用

    public class StaticInitTest {
    public static void main(String[] args) {
        /**
         *   这里是对StaticParent的主动使用，而不是StaticChild.
         *   因为访问的都是父类静态变量或者静态方法
         */
        System.out.println(StaticChild.a);
        StaticChild.println();
    }
}

class StaticParent {
    static int a = 20;

    static {
        System.out.println("parent static block");
    }

    static void println() {
        System.out.println("parent println");
    }
}

class StaticChild extends StaticParent {
    static {
        System.out.println("child static block");
    }
}

  2. 输出

    parent static block
20
parent println

类的加载与初始化

  1. java系统加载并初始化某个类时，总是保证该类所有父类（直接父类和间接父类）全部加载并初始化。

    public class ClassTest {
    public static void main(String[] args) {
        new Man();
        System.out.println("-----");
        new Man();
    }
}

class Human {
    static {
        System.out.println("0.human static block");
    }

    {
        System.out.println("1.human 构造块 ");
    }

    public Human() {
        System.out.println("2.human 构造方法 ");
    }
}


class Man extends Human {
    static {
        System.out.println("0.Man static block");
    }

    {
        System.out.println("1.Man 构造块 ");
    }

    public Man() {
        System.out.println("2.Man 构造方法 ");
    }
}

    输出,静态代码块只会执行一次，构造块优先于构造方法执行，父类构造块和构造方法优先于子类的构造块和构造方法执行

    0.human static block
0.Man static block
1.human 构造块 
2.human 构造方法 
1.Man 构造块 
2.Man 构造方法 
-----
1.human 构造块 
2.human 构造方法 
1.Man 构造块 
2.Man 构造方法

接口的加载与初始化

  1. 验证接口的加载

    /**
 * 1. 增加jvm参数
 * -XX:+TraceClassLoading   跟踪类的加载(包括动态生成的类的加载)
 * -XX:+TraceClassUnloading 跟踪类的卸载(包括动态生成的类的卸载)
 */
public class InterfaceLoaderTest {
    public static void main(String[] args) {
        System.out.println(ChildInterface.b);
    }
}
interface ParentInterface {
    public final static int a = 20;
}

interface ChildInterface extends ParentInterface {
    public final static int b = 30;
}

    以下输出可以看出，ParentInterface和ChildInterface都没有被加载，只有InterfaceLoaderTest被加载

    ...省略...
[Loaded init.InterfaceLoaderTest from file:/Volumes/O/java-classloader/out/production/classes/]
30
...省略...

  2. 验证接口的初始化

    /**
 * 1. 增加jvm参数
 * -XX:+TraceClassLoading   跟踪类的加载(包括动态生成的类的加载)
 * -XX:+TraceClassUnloading 跟踪类的卸载(包括动态生成的类的卸载)
 */
public class InterfaceInitTest {
    public static void main(String[] args) {
        System.out.println(ChildInitInterface.b);
    }
}

interface ParentInitInterface {
    /**
     * 1. 这里定义一个Object的子类，并且使用初始化代码进行初始化
     * 2. 如果此obj的初始化代码被执行，则表示ParentInitInterface被初始化了
     */
    public final static Object obj = new Object() {
        {
            System.out.println("ParentInitInterface 初始化了");
        }
    };
}

interface ChildInitInterface extends ParentInitInterface {
    //匿名内部类
    public final static Object b = new Object() {
        {
            System.out.println("ChildInitInterface 初始化了");
        }
    };
}

    以下输出可以看出，ParentInitInterface、ChildInitInterface和匿名内部类都加载了，但是主动使用ChildInitInterface时，ParentInitInterface并没有初始化,即一个接口在初始化时，父接口并不一定要初始化(当然如果接口引用父接口时，父接口会初始化)

    ...省略...
[Loaded init.ParentInitInterface from file:/Volumes/O/java-classloader/out/production/classes/]
[Loaded init.ChildInitInterface from file:/Volumes/O/java-classloader/out/production/classes/]
[Loaded init.ChildInitInterface$1 from file:/Volumes/O/java-classloader/out/production/classes/]
ChildInitInterface 初始化了
init.ChildInitInterface$1@45ee12a7
...省略...

  3. 验证实现类与接口的初始化化

    /**
 * 1. 增加jvm参数
 * -XX:+TraceClassLoading   跟踪类的加载(包括动态生成的类的加载)
 * -XX:+TraceClassUnloading 跟踪类的卸载(包括动态生成的类的卸载)
 */
public class ClassInitTest {
    public static void main(String[] args) {
        System.out.println(ChildClassInit.b);
    }
}

interface ParentClassInitInterface {
    public final static int a = 20;
    /**
     * 1. 这里定义一个Object的子类，并且使用初始化代码进行初始化
     * 2. 如果此obj的初始化代码被执行，则表示ParentInitInterface被初始化了
     */
    public final static Object obj = new Object() {
        {
            System.out.println("ParentClassInitInterface 初始化了");
        }
    };
}

class ChildClassInit implements ParentClassInitInterface {
  // 此处不要加final
   public static int b = 30;
}

    输出结果可以看出，当类被初始化的，类所实现的接口不会被初始化

    ...省略...
[Loaded init.ClassInitTest from file:/Volumes/O/java-classloader/out/production/classes/]
[Loaded init.ParentClassInitInterface from file:/Volumes/O/java-classloader/out/production/classes/]
[Loaded init.ChildClassInit from file:/Volumes/O/java-classloader/out/production/classes/]
30
...省略...

  4. 总结:java系统加载并初始化某个类时，总是保证该类所有父类（直接父类和间接父类）全部加载并初始化。但是此规则不适用于接口。在初始化一个类时，并不会初始化它所实现的接口。在初始化一个接口时，并不会先初始化它的父接口。只有当程序首次使用特定接口的静态变量时，才会导致接口的初始化

综合案例

  1. 初始化案例一

    class Singleton {

    public static Singleton singleton = new Singleton();
    public static int a;
    public static int b = 0;

    private Singleton() {
        super();
        a++;
        b++;
    }

    public static Singleton GetInstence() {
        return singleton;
    }

    /**
     * 输出
     * 1
     * 0
     */
    public static void main(String[] args) {
        Singleton singleton = Singleton.GetInstence();
        System.out.println(singleton.a);
        System.out.println(singleton.b);
    }

}

  2. 初始化案例二

    class Singleton2 {

    public static int a;
    public static int b = 0;
    public static Singleton2 singleton = new Singleton2();

    private Singleton2() {
        super();
        a++;
        b++;
    }

    public static Singleton2 GetInstence() {
        return singleton;
    }

    /**
     * 输出
     * 1
     * 1
     */
    public static void main(String[] args) {
        Singleton2 singleton2 = Singleton2.GetInstence();
        System.out.println(singleton2.a);
        System.out.println(singleton2.b);
    }
}

  3. 以上两端代码的区别就是顺序的区别，为什么顺序会决定输出的结果呢？这与JVM加载类的原理有直接的关系

    案例一
public static Singleton singleton = new Singleton();
public static int a;
public static int b = 0;

案例二
public static int a;
public static int b = 0;
public static Singleton2 singleton = new Singleton2();

  4. java类在被使用前要经过如下几个阶段

    • 类加载:将磁盘中的class文件加载到内存中，在堆中创建一个对应的java.lang.Class的对象
    • 连接
      • 验证:验证内存的字节码文件是否符合JVM规范
      • 准备:将类的静态变量分配空间并初始化默认值。此时对象没有生成，所以没有实例变量什么事情
      • 解析:把类的符号引用转为直接引用
    • 类的初始化:将类的静态变量赋予正确的初始值，这个初始值是开发者自己定义时赋予的初始值，而不是默认值。

  5. 案例一解析，main方法调用Singleton.GetInstence()属于主动使用，所以jvm会按照如下方式处理

    • 加载Singleton类

    • 连接

      • 验证字节码文件

      • 对Singleton的所有静态变量分配内存空间并赋默认值

        此时静态变量
singleton = null
a = 0 
b = 0

      • 解析

    • 初始化:此时对静态变量赋值，即手动赋予的初始值

      //singleton被赋值，构造方法调用a++ b++ ，所以此时a=1 b=1 
public static Singleton singleton = new Singleton();
//a 没有被赋值,所以此时a = 1
public static int a;
//b 被重新赋值为0，即覆盖了上面的b=1的值
public static int b = 0;
所以最终的结果是
a = 1
b = 0

  6. 案例二解析，案例二与案例一不同之处在于初始化阶段

    //a没有被赋值，所以保持默认初始值0
public static int a;
//b被赋值，b = 0
public static int b = 0;
//singleton被赋值，构造方法调用a++ b++ ，所以此时a=1 b=1 
public static Singleton2 singleton = new Singleton2();

所以最终的结果是
a = 1
b = 1
jannals
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类加载与类初始化
12-22
JVM把class文件加载到内存，并对数据进行校验、解析和初始化，最终形成 JVM可以直接使用的Java类型的过程。 \quad·加载 \quad\quad将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时...
JVM初始化阶段简述
m0_53288098的博客
01-06 549
1<clinit>()方法 JVM初始化阶段就是执行类变量构造器方法<clinit>()的过程，对准备阶段产生的默认零值进行赋值。此方法无需定义，是由javac编译器自动收集类中的所有类变量的赋值动作和静态代码块，并将其进行合并。 只有被static修饰并且赋值的静态属性才会产生<clinit>()方法，不管是直接赋值还是在静态块中赋值，最后都会被合并成一个<clinit>()方法，并按照代码中的顺序依次赋值。 publ...
类加载和初始化 —— JVM篇
YING—country的博客
03-18 2207
类加载和初始化 一、Class Cycle（类的加载过程） 类的周期 一个类的完整生命周期如下： 类的加载过程 ​ Class文件在我们硬盘中，需要加载到虚拟机中之后才能运行和使用，那么虚拟机是如何加载这些 Class 文件呢？ ​ 系统加载 Class 类型的文件主要三步：加载->连接->初始化。连接过程又可分为三步：验证->准备->解析。 详见：jvm规范5.4 。 1.Loading步骤（加载） 类加载过程的第一步，主要完成下面 3 件事情： 通过全类名获取定义此
JVM之初始化
TofuCai的博客
08-29 1053
类的生命周期 加载  验证  准备  解析  初始化  使用  卸载 其中类加载的过程包括了加载、验证、准备、解析、初始化五个阶段。在这五个阶段中，加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段则不一定，它在某些情况下可以在初始化阶段之后开始，这是为了支持Java语言的运行时绑定（也成为动态绑定或晚期绑定）。另外注意这里的几个阶段是按顺序开始，而不是按顺序进行或完成，因为这些...
JVM类初始化过程
小海豚の家
11-13 846
JVM类初始化过程 类加载机制 **类加载机制主要有三步: 加载、连接、初始化。 ** 加载 ​ 把编译好的class文件加载进内存 (1.7及之前为方法区，1.8取消方法区，用元数据区替代) 中，并在堆中创建对应的Class对象。 连接 验证 ​ 验证加载的类信息是否符合JVM规范，确保安全 准备 ​ 为静态变量分配内存并设置默认的初始值 解析 ​ 将类的二进制数据中的符号引用替换成直接引用 初始化 ​ 静态变量赋值 -> 静态代码块 -> 成员变量 ->
JVM类加载系列之初始化过程
a_ittle_pan的博客
04-25 932
引言 一星期一更的节目可能会迟到，但永远不会缺席！！！ 参考书籍：“深入理解java虚拟机” 初始化（Initiallization） 初始化阶段，简言之，为类的静态变量赋予正确的初始值。 具体描述： 类的初始化是类装载的最后一个阶段，如果前面的步骤都没有问题，那么表示类可以顺利装载到系统中。此时，类才会开始执行Java字节码。（即：到了初始化阶段，才真正开始执行类中定义的Java程序代码。） 初始化阶段的重要工作是执行类的初始化方法：clinit（）方法 该方法仅能由Java编译器生成并由JVM调
轻松搞定jvm类加载器
12-22
类的加载、连接、初始化 1. 加载 通过类的包名和雷鸣查找到此类的字节码文件，将xx.class文件中的二进制数据读入到jvm内存，并存入其中的方法区内，然后利用字节码文件创建一个class对象存入到堆之中，用来封装类的...
Java虚拟机之类加载机制
12-22
后在运行的时候，虚拟机把描述类的信息从class文件加载到内存，然后再进行校验、解析和初始化等过程，后形成可以被java虚拟机“读懂”的java类型。那么从class——>java虚拟机能“读懂”的java类型是本文要讲解的...
Java提高篇之关键字static
12-22
在JVM加载一个类的时候，若该类存在static修饰的成员变量和成员方法，则会为这些成员变量和成员方法在固定的位置开辟一个固定大小的内存区域，有了这些“固定”的特性，那么JVM可以非常方便地访问他们。同时如果静态...
Android面试（一）Java虚拟机内存结构分析
12-22
虚拟机栈：线程创建之初，Java虚拟机会为每一个线程开辟一块虚拟机栈空间，存储线程方法调用的局部变量，计算中间量，参数等，是线程私有的内存区域。 本地方法栈：线程私有的用于native方法引用的内存栈空间。 程序...
什么时候会发生类初始化
weixin_49578980的博客
10-10 235
什么时候会发生类初始化 类的主动引用(一定会发生类的初始化) 当虚拟机启动,先初始化main方法所在的类 new一个类的对象 调用类的静态成员(除了final常量)和静态方法 使用java.lang.reflect包的方法对类进行反射调用 当初始化一个类,如果其父类没有被初始化,则会先初始化它的父类 类的被动引用(不会发生类的初始化) 当访问一个静态域时,只有真正声明这个域的类才会被初始化.如:当通过子类调用父类的静态变量,不会导致子类初始化 通过数组定义类引用,不会触发此类的初始化 引用常量不会
JVM 的类初始化机制
一个有趣、有料、有内涵的地方!
08-08 198
前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相...
JVM类的初始化步骤
aaa_aaa_aaa_aa的博客
04-22 417
假如这个类还没有被加载和连接，那就先进行加载和连接 假如类存在直接父类，并且这个父类还没有被初始化，那么就先初始化直接父类 假如类中存在初始化语句，那就依次执行这些初始化语句 类加载的初始化赋值是按照代码声明的顺序进行 public class ClassLoadTest { /** * 当调用一个类的静态方法时触发对这个类进行初始化 * @param args */ public static void main(String[] args) { Singleton sing
【JVM】类加载、连接和初始化过程
littlecolor
08-04 5407
程序运行时，加载类主要经过3个阶段分别是类的加载，连接和初始化。分别介绍一下这三个过程。 一、加载类的加载指的是将类的.class文件中二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class对象，用来封装类在方法区内的数据结构。 加载.class文件的方式1、从本地系统中直接加载 2、通过网络下载.class文件 3、从zip,jar等归档文件中加
jvm - 类的初始化过程
拨开云雾看世界
12-31 4050
加载->链接->初始化　　我们知道，我们写的java代码称为源码，想要能够被jvm执行首先需要编译成.class文件，那么编译完到使用又都经理的哪些阶段呢？主要分为以下三个阶段： 加载：查找并加载类的二进制数据（.class文件硬盘到内存的一个过程）。 连接 　- 验证：确保被加载的类的正确性。 　- 准备：为类的 静态变量分配内存，并将其初始化为默认值。 　- 解析：把类中的符号引用转
【JVM总结】类的加载、连接和初始化
fxkcsdn的博客
08-07 2020
什么是类的加载 jvm将class文读取到内存中，经过对class文件的校验、转换解析、初始化最终在jvm的heap和方法区分配内存形成可以被jvm直接使用的类型的过程。 类的生命周期7个阶段依次为：Loading Verification Preparation Resolution Initialization Using Unloading 加载 验证 准备 初始化和卸载 的...
JAVA虚拟机（JVM）——类加载的时机之类的初始化
chenge_j的博客
05-24 2347
类的生命周期 从类被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括如上的7个阶段。其中，验证、准备、解析这三个部分又被统称为“连接（Linking）。类的加载过程必须按照这种顺序按部就班的开始，而解析阶段则不一定，它在某些情况下是可以在初始化阶段之后再开始的，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。 对类进行初始化的条件 什么情况下需要开始类加载
JVM（1）类加载及初始化过程详解
weixin_43935299的博客
09-27 555
类的初始化详解
JVM 类加载初始化过程 <init> <clinit>
Nut___的博客
09-20 654
一、需明白的几个概念 <init> 实例的初始化方法 就是我们说的构造器，构造器就包括 构造方法、{}包住的代码等。 <clinit> 类的初始化方法 1、<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}语句）中的语句合并产生的，编译器收集的顺序是有语句在源文件中出现的顺序所决定的，静态语句块中只能访问到...
具体讲讲JVM类加载中的解析过程
最新发布
08-26
如果初始化一个类时发生异常，则会抛出java.lang.ExceptionInInitializerError异常。 JVM的类加载器有以下几种： 1. 启动类加载器（Bootstrap ClassLoader）：它是最顶层的类加载器，负责加载JVM的核心类库，如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值