精华内容
下载资源
问答
  • 类加载过程

    2019-05-11 09:33:33
    类加载过程 实例是实例,类是类,不可混为一谈。类的加载过程和实例信息没有任何关系,仅与类信息有关 类加载过程指的是将【类】信息加载到内存,第一次使用到这个类的时候才会加载,并且会查看其父类是否已加载。...

    类加载过程

    实例是实例,类是类,不可混为一谈。类的加载过程和实例信息没有任何关系,仅与类信息有关

    类加载过程指的是将【类】信息加载到内存,第一次使用到这个类(创建类的实例,或者调用静态方法or静态变量)的时候才会加载,并且会查看其父类是否已加载。java中类是动态加载的,而且只加载一次。

    一个类所有信息如下:
    在这里插入图片描述
    加载过程如下:
     1、在方法区分配保存类信息的内存空间
     2、给类变量赋【默认值】
     3、加载父类
     4、设置父子关系
     5、执行【类】初始化代码
    类初始化代码包含:类(静态)变量赋值语句+static{} 静态代码块2部分组成。是先执行父类的,在执行子类的,不过,在执行父类类初始化代码的时候,子类类变量是有默认值【步骤2已执行】。


     栈:存放方法的局部变量
     堆:存放对象
     方法区:存放类的信息

    展开全文
  • JVM类加载过程

    万次阅读 多人点赞 2019-06-20 15:10:25
    1. JVM类加载过程 1.概述 从类的生命周期而言,一个类包括如下阶段: 加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的,类的加载过程必须按照这种顺序进行,而解析阶段则不一定,它在某些情况下...

    1. JVM类加载过程

        1.概述

        从类的生命周期而言,一个类包括如下阶段:

        

            加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的,类的加载过程必须按照这种顺序进行,而解析阶段则不一定,它在某些情况下可能在初始化阶段后在开始,因为java支持运行时绑定。

        2. 类加载时机

        加载(loading)阶段,java虚拟机规范中没有进行约束,但初始化阶段,java虚拟机严格规定了有且只有如下5种情况必须立即进行初始化(初始化前,必须经过加载、验证、准备阶段):

        (1)使用new实例化对象时,读取和设置类的静态变量、静态非字面值常量(静态字面值常量除外)时,调用静态方法时。

        (2)对内进行反射调用时。

        (3)当初始化一个类时,如果父类没有进行初始化,需要先初始化父类。

        (4)启动程序所使用的main方法所在类

        (5)当使用1.7的动态语音支持时。

        如上5种场景又被称为主动引用,除此之外的引用称为被动引用,被动引用有如下3种常见情况

    • 通过子类引用父类的静态字段,只会触发父类的初始化,而不会触发子类的初始化。
    • 定义对象数组和集合,不会触发该类的初始化
    • 类A引用类B的static final常量不会导致类B初始化(注意静态常量必须是字面值常量,否则还是会触发B的初始化)
    public class TestClass {
        public static void main(String[] args) {
            System.out.println(ClassInit.str);
            System.out.println(ClassInit.id);
        }
    }
    class ClassInit{
        public static final long id=IdGenerator.getIdWorker().nextId();//需要初始化ClassInit类
        public static final String str="abc";//字面值常量
        static{
            System.out.println("ClassInit init");
        }
    }
    • 通过类名获取Class对象,不会触发类的初始化。如System.out.println(Person.class);
    • 通过Class.forName加载指定类时,如果指定参数initialize为false时,也不会触发类初始化。
    • 通过ClassLoader默认的loadClass方法,也不会触发初始化动作

        注意:被动引用不会导致类初始化,但不代表类不会经历加载、验证、准备阶段。

        3. 类加载方式

        这里的类加载不是指类加载阶段,而是指整个类加载过程,即类加载阶段到初始化完成。

       (1)隐式加载

    • 创建类对象
    • 使用类的静态域
    • 创建子类对象
    • 使用子类的静态域
    • 在JVM启动时,BootStrapLoader会加载一些JVM自身运行所需的class
    • 在JVM启动时,ExtClassLoader会加载指定目录下一些特殊的class
    • 在JVM启动时,AppClassLoader会加载classpath路径下的class,以及main函数所在的类的class文件

        (2)显式加载

    • ClassLoader.loadClass(className),只加载和连接、不会进行初始化
    • Class.forName(String name, boolean initialize,ClassLoader loader); 使用loader进行加载和连接,根据参数initialize决定是否初始化。

    2. 加载阶段

        加载是类加载过程中的一个阶段,不要将这2个概念混淆了。

        在加载阶段,虚拟机需要完成以下3件事情:

    • 通过一个类的全限定名来获取定义此类的二进制字节流
    • 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
    • 在内存中生成一个代表这个类的java.lang.Class对象,作为方法区这个类的各种数据的访问入口。

        加载.class文件的方式

    • 从本地系统中直接加载
    • 通过网络下载.class文件
    • 从zip,jar等归档文件中加载.class文件
    • 从专有数据库中提取.class文件
    • 将Java源文件动态编译为.class文件    

        相对于类生命周期的其他阶段而言,加载阶段(准确地说,是加载阶段获取类的二进制字节流的动作)是可控性最强的阶段,因为开发人员既可以使用系统提供的类加载器来完成加载,也可以自定义自己的类加载器来完成加载。

    3. 连接阶段

      3.1 验证:确保被加载的类的正确性

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

    • 文件格式验证:验证字节流是否符合Class文件格式的规范,如:是否以模数0xCAFEBABE开头、主次版本号是否在当前虚拟机处理范围内等等。
    • 元数据验证:对字节码描述的信息进行语义分析,以保证其描述的信息符合Java语言规范的要求;如:这个类是否有父类,是否实现了父类的抽象方法,是否重写了父类的final方法,是否继承了被final修饰的类等等。
    • 字节码验证:通过数据流和控制流分析,确定程序语义是合法的、符合逻辑的,如:操作数栈的数据类型与指令代码序列能配合工作,保证方法中的类型转换有效等等。
    • 符号引用验证:确保解析动作能正确执行;如:通过符合引用能找到对应的类和方法,符号引用中类、属性、方法的访问性是否能被当前类访问等等。

        验证阶段是非常重要的,但不是必须的。可以采用-Xverify:none参数来关闭大部分的类验证措施。

      3.2 准备:为类的静态变量分配内存,并将其赋默认值

        为类变量分配内存并设置类变量初始值,这些内存都将在方法区中分配。对于该阶段有以下几点需要注意:

    • 只对static修饰的静态变量进行内存分配、赋默认值(如0、0L、null、false等)。
    • 对final的静态字面值常量直接赋初值(赋初值不是赋默认值,如果不是字面值静态常量,那么会和静态变量一样赋默认值)。

      3.3 解析:将常量池中的符号引用替换为直接引用(内存地址)的过程

        符号引用就是一组符号来描述目标,可以是任何字面量。属于编译原理方面的概念如:包括类和接口的全限定名、字段的名称和描述符、方法的名称和描述符。

        直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。如指向方法区某个类的一个指针。

        假设:一个类有一个静态变量,该静态变量是一个自定义的类型,那么经过解析后,该静态变量将是一个指针,指向该类在方法区的内存地址。 具体见后续文章。

    4. 初始化:为类的静态变量赋初值

        赋初值两种方式:

    • 定义静态变量时指定初始值。如 private static String x="123";
    • 静态代码块里为静态变量赋值。如 static{ x="123"; } 

        注意:只有对类的主动使用才会导致类的初始化。

    5. clinit 与 init

        在编译生成class文件时,编译器会产生两个方法加于class文件中,一个是类的初始化方法clinit, 另一个是实例的初始化方法init。

      5.1 clinit 

        clinit指的是类构造器,主要作用是在类加载过程中的初始化阶段进行执行,执行内容包括静态变量初始化和静态块的执行。

        注意事项:

        1. 如果类中没有静态变量或静态代码块,那么clinit方法将不会被生成。

        2. 在执行clinit方法时,必须先执行父类的clinit方法。

        3. clinit方法只执行一次。

        3. static变量的赋值操作和静态代码块的合并顺序由源文件中出现的顺序决定。如下代码所示:

    public class TestClass {
        public static void main(String[] args) {
            ClassInit init=ClassInit.newInstance();
    
            System.out.println(init.x);
            System.out.println(init.y);
        }
    }
    
    class ClassInit{
        private static ClassInit init=new ClassInit();
        public static int x;
        public static int y=0;
        static{
            x=10;
            y=10;
        }
        private ClassInit(){
            x++;
            y++;
        }
        public static ClassInit newInstance(){
            return init;
        }
    }
    //在类加载到连接完成阶段,ClassInit类在内存中的状态为:init=null,x=0,y=0
    //初始化阶段时,需要执行clinit方法,该方法类似如下伪代码:
    clinit(){
    	//init=new ClassInit();调用构造方法
        x++;//x=1 因为此时x的值为连接的准备阶段赋的默认值0,然后++变成1
        y++;//y=1 因为此时y的值为连接的准备阶段赋的默认值0,然后++变成1
        //x=0;//为什么这里没有执行x=0,因为程序没有给x赋初值,因此在初始化阶段时,不会执行赋初值操作
        y=0;//因为类变量y在定义时,指定了初值,尽管初值为0,因此在初始化阶段的时候,需要执行赋初值操作
        x++;//第一个静态块的自增操作,结果为x=2;
        y++;//第一个静态块的自增操作,结果为y=1;
    }
    //所以最终结果为x=2,y=1
    //如果private static ClassInit init=new ClassInit(); 代码在public static int y=0;后面,那么clinit方法的伪代码如下:
    clinit(){
        //x=0;//这里虽然没有执行,但此时x的值为连接的准备阶段赋的默认值0
        y=0;//因为类变量y在定义时,指定了初值,尽管初值为0,因此在初始化阶段的时候,需要执行赋初值操作
    	//init=new ClassInit();调用构造方法
        x++;//x=1 因为此时x的值为连接的准备阶段赋的默认值0,然后++变成1
        y++;//y=1 因为此时y的值为初始化阶段赋的初值,只是这个初值刚好等于默认值0而已,然后++变成1
        x++;//第一个静态块的自增操作,结果为x=2;
        y++;//第一个静态块的自增操作,结果为y=2;
    }
    //最终结果为x=2,y=2

        5.2 init

        init指的是实例构造器,主要作用是在类实例化过程中执行,执行内容包括成员变量初始化和代码块的执行。

        注意事项:

        1. 如果类中没有成员变量和代码块,那么clinit方法将不会被生成。

        2. 在执行init方法时,必须先执行父类的init方法。

        3. init方法每实例化一次就会执行一次。

        3. init方法先为实例变量分配内存空间,再执行赋默认值,然后根据源码中的顺序执行赋初值或代码块。如下代码所示:

    public class TestClass {
        public static void main(String[] args) {
            ClassInit init=new ClassInit();
        }
    }
    
    class ClassInit{
        public int x;
        public int y=111;
        public ClassInit(){
            x=1;
            y=1;
        }
        {
            x=2;
            y=2;
        }
        {
            x=3;
            y=3;
        }
    }
    //实例化步骤为:先为属性分配空间,再执行赋默认值,然后按照顺序执行代码块或赋初始值,最后执行构造方法
    //根据上述代码,init方法的伪代码如下:
    init(){
    	x=0;//赋默认值
        y=0;//赋默认值
        y=111;//赋初值
        x=2;//从上到下执行第一个代码块
        y=2;//从上到下执行第一个代码块
        x=3;//从上到下执行第二个代码块
        y=3;//从上到下执行第二个代码块
        //ClassInit();执行构造方法
        x=1;//最后执行构造方法
        y=1;//最后执行构造方法
    }
    //如果上述代码的成员变量x,y的定义在类最后时,那么init方法的伪代码如下:
    init(){
    	x=0;//赋默认值
        y=0;//赋默认值
        x=2;//从上到下执行第一个代码块
        y=2;//从上到下执行第一个代码块
        x=3;//从上到下执行第二个代码块
        y=3;//从上到下执行第二个代码块
        y=111;//赋初值
        //ClassInit();执行构造方法
        x=1;//最后执行构造方法
        y=1;//最后执行构造方法
    }

    6. 卸载阶段

        执行了System.exit()方法

        程序正常执行结束

        程序在执行过程中遇到了异常或错误而异常终止

        由于操作系统出现错误而导致Java虚拟机进程终止
       

    展开全文
  • dalvik启动过程、类加载流程、so加载过程 以下内容均是通过阅读老罗博客总结而来: https://www.kancloud.cn/alex_wsc/androids/473610 一、dalvik启动流程 二、类加载流程 三、so加载过程 ...

    dalvik启动过程、类加载流程、so加载过程

    以下内容均是通过阅读老罗博客总结而来:
    https://www.kancloud.cn/alex_wsc/androids/473610

    一、dalvik启动流程

    二、类加载流程

    三、so加载过程

    展开全文
  • Class类加载过程与类加载器

    千次阅读 2020-05-02 19:03:55
    在说类加载器和双亲委派模型之前,先来梳理下Class类文件的加载过程,JAVA...类加载过程 Class类从被加载到虚拟机内存开始,到卸载出内存为止,其生命周期包括:加载(Loading)、验证(Verification)、准备(Prepa...

    在说类加载器和双亲委派模型之前,先来梳理下Class类文件的加载过程,JAVA虚拟机为了保证 实现语言的无关性,是将虚拟机只与“Class 文件”字节码这种特定形式的二进制文件格式相关联,而不是与实现语言绑定。所以其不一定是Class文件。

    类加载过程

    Class类从被加载到虚拟机内存开始,到卸载出内存为止,其生命周期包括:加载(Loading)、验证(Verification)、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)、卸载(Unloading)7个阶段。其中加载过程见下:

    在这里插入图片描述

    加载阶段

    加载阶段做了什么?过程见下图。其中类的全限定名是Class文件(JAVA由编译器自动生成)内的代表常量池内的16进制值所代表的特定符号引用。因为Class文件格式有其自己的一套规范,如第1-4字节代表魔数,第5-6字节代表次版本,第7-8字节代表主版本号等等。

    在这里插入图片描述

    说白了就是,虚拟机不关心我们的这种“特定二进制流”从哪里来的,从本地加载也好,从网上下载的也罢,都没关系。虚拟机要做的就是将该二进制流写在自己的内存中并生成相应的Class对象(并不是在堆中)。在这个阶段,我们能够通过我们自定义类加载器来控制二进制流的获取方式。

    验证阶段

    验证阶段,正因为加载阶段虚拟机不介意二进制的来源,所以就可能存在着影响虚拟机正常运行的安全隐患。所以虚拟机对于该二进制流的校验工作非常重要。校验方式包括但不限于:

    在这里插入图片描述

    准备阶段

    准备阶段在此阶段将正式为类变量分配内存并设置变量的初始化值。注意的是,类变量是指 static 的静态变量,是分配在方法区之中的,而不像对象变量,分配在堆中。还有一点需要注意,final 常量在此阶段就已经被赋值了。如下:

        public static int SIZE = 10; // 初始化值 == 0
        public static final int SIZE = 10; // 初始化值 == 10
    
    解析阶段

    解析阶段是将常量池内的符号引用替换为直接引用的过程。符号引用就是上文说的Class文件格式标准所规定的特定字面量,而直接引用就是我们说的指针,内存引用等概念

    初始化阶段

    到了初始化阶段,就开始真正执行我们的字节码程序了。也可以理解成:类初始化阶段就是虚拟机内部执行类构造 < clinit >() 方法的过程。注意,这个类构造方法可不是虚拟机内部生成的,而是我们的编译器自动生成的,是编译器自动收集类中的所有类变量的赋值动作和静态语句块(static{}块)中的语句合并产生的,具体分析见下。

    注意,这里说的是类变量赋值动作,即static 并且具有赋值操作,如果无赋值操作,那么在准备阶段进行的方法区初始化就算完成了。为何还要加上static{} 呢?我们可以把static{} 理解成:是由多个静态初始化动作组织成的一个特殊的“静态子句”,与其他的静态初始化动作一样。这也是为何 static {} 只会执行一遍并在对象构造方法之前执行的原因。如下代码:

    public class Tested {
        public static int T;
        // public static int V; // 无赋值,不在类构造中再次初始化
        public int c = 1; // 不会在类构造中
    
        static {
            T = 10;
        }
    }
    

    还有一点,编辑器收集类变量的顺序,也就是虚拟机在此初始化阶段的执行顺序,这个顺序就是变量在类中语句定义的先后顺序,如上面的:语句 2 : T 在 6 : T 之前,这是两个独立的语句。类构造< clinit >的其他特点如下:

    在这里插入图片描述

    编译期的< clinit >

    我们将流程回溯到编译期阶段,以刚刚的Tested 类代码为例。通过 javap -c /Tested.class (注意:/…/Tested 绝对路径),获取Class文件:

    public class com.tencent.lo.Tested {
      public static int T;
    
      public int c;
    
      public com.tencent.lo.Tested();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: aload_0
           5: iconst_1
           6: putfield      #2                  // Field c:I
           9: return
    
      static {};
        Code:
           0: bipush        10
           2: putstatic     #3                  // Field T:I
           5: return
    }
    

    在Class 文件中我们能很明显的看到 invokespecial 对应的对象构造 “< init >” : () V ,那为什么没有看到< clinit > 类构造方法呢?其实上面的 static {} 就是。我们来看下OpenJDK源码Constants接口,此接口定义了在编译器中所用到的常量,这是一个自动生成的类。

    public interface Constants extends RuntimeConstants {
        public static final boolean tracing = true;
    
        Identifier idClassInit = Identifier.lookup("<clinit>");
        Identifier idInit = Identifier.lookup("<init>");
    }
    

    MemberDefinition类 中,判断是否为类构造器字符:

        public final boolean isInitializer() {
            return getName().equals(idClassInit); // 类构造
        }
        public final boolean isConstructor() {
            return getName().equals(idInit); // 对象构造
        }
    

    而在MemberDefinition 的 toString() 方法中,我们能够看到,当类构造时,会输出特定字符,而不会像对象构造那样输出规范的字符串。

        public String toString() {
            Identifier name = getClassDefinition().getName();
            if (isInitializer()) { // 类构造
                return isStatic() ? "static {}" : "instance {}";
            } else if (isConstructor()) { // 对象构造
                StringBuffer buf = new StringBuffer();
                buf.append(name);
                buf.append('(');
                Type argTypes[] = getType().getArgumentTypes();
                for (int i = 0 ; i < argTypes.length ; i++) {
                    if (i > 0) {
                        buf.append(',');
                        }
                    buf.append(argTypes[i].toString());
                    }
                buf.append(')');
                return buf.toString();
            } else if (isInnerClass()) {
                return getInnerClass().toString();
            }
            return type.typeString(getName().toString());
        }
    

    类加载器与双亲委派

    “虚拟机将类加载阶段中的“通过一个全限定名来获取描述此类的二进制字节流”这个动作放到了外部来实现,以便开发者可以自己决定如何获取所需的类文件,而实现这个动作的代码模块就被称为类加载器。对于任意一个类来说,只有在类加载器相同的情况下比较两者是否相同才有意义,否则即使是同个文件,在不同加载器下,在虚拟机看来其仍然是不同的,是两个独立的类。我们可以将类加载器分为三类”:

    在这里插入图片描述
    而所谓的双亲委派模型就是:“如果一个类加载器收到类加载的请求,它首先不会自己去尝试加载这个类,而是把加载的操作委托给父类加载器去完成,每一层次加载器都是如此,因此所有的加载请求都会传送到顶层的启动类加载器中,只有当父加载器反馈自己无法完成这个加载请求时(它的搜索范围没有找到所需的类,因为上面所说的启动类加载器和扩展类加载器,只能加载特定目录之下的,或被-x参数所指定的类库),子类才会尝试自己加载”。注意这里说的父类只是形容层次结构,其并不是直接继承关系,而是通过组合方式来复用父类的加载器的。

    在这里插入图片描述
    “双亲委派的好处就是,使加载器也具备了优先级的层次结构。例如,java.lang.Object存放在< JAVA_HOME>\lib 下的rt.jar包内,无论哪个类加载器要加载这个类,最终都会委派给最顶层的启动类加载器,所以保证了Object类在各类加载器环境中都是同一个类。相反,如果没有双亲委派模型,如果用户编写了一个java.lang.Object类,并放在程序的ClassPath下,那么系统将会出现多个不同的Object类”。

    为何?因为每个加载器各自为政,不会委托给父构造器,如上面所说,只要加载器不同,即使类Class文件相同,其也是独立的。

    试想如果自己在项目中编写了一个java.lang.Object 类(当然不能放入rt.jar类库中替换掉同名Object文件,这样做没有意义,如果虚拟机加载校验能通过的话,只是相当于改了源码嘛),我们通过自定义的构造器来加载这个类可以吗?理论上来说,虽然这两个类都是java.lang.Object,但由于构造器不同,对于虚拟机来说这是不同的Class文件,当然可以。但是实际上呢?来段代码见下:

        public void loadPathName(String classPath) throws ClassNotFoundException {
            new ClassLoader() {
                @Override
                public Class<?> loadClass(String name) throws ClassNotFoundException {
                    InputStream is = getClass().getResourceAsStream(name);
                    if (is == null)
                        return super.loadClass(name);
                    byte[] b;
                    try {
                        b = new byte[is.available()];
                        is.read(b);
                    } catch (Exception e) {
                        return super.loadClass(name);
                    }
                    return defineClass(name, b, 0, b.length);
                }
            }.loadClass(classPath);
        }
    

    实际的执行逻辑是 defineClass 方法。可以发现,自定义加载器是无法加载以 java. 开头的系统类的。

        protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                             ProtectionDomain protectionDomain)
                throws ClassFormatError {
            
            protectionDomain = preDefineClass(name, protectionDomain);
            ... // 略
    
            return c;
        }
    
        private ProtectionDomain preDefineClass(String name, ProtectionDomain pd) {
            if (!checkName(name))
                throw new NoClassDefFoundError("IllegalName: " + name);
            // 在这里能看到系统类,自定义的加载器是不能加载的
            if ((name != null) && name.startsWith("java.")) {
                throw new SecurityException
                        ("Prohibited package name: " +
                                name.substring(0, name.lastIndexOf('.')));
            }
            ... // 略
            
            return pd;
        }
    

    如果你用AS直接查看,你会发现,defineClass 内部是没有具体实现的,源码见下。可这并不代表android 的 defineClass 方法实现与 java 不同,因为都是引用的 java.lang 包下的ClassLoader 类,逻辑肯定都是一样的。之所以看到的源码不一样,这是由于SDK和JAVA源码包的区别导致的。SDK内的源码是谷歌提供给我们方便开发查看的,并不完全等同于源码。

        protected final Class<?> defineClass(String name, byte[] b, int off, int len)
            throws ClassFormatError
        {
            throw new UnsupportedOperationException("can't load this type of class file");
        }
    

    参考
    1、周志明,深入理解JAVA虚拟机:机械工业出版社

    展开全文
  • title: 类加载机制(一):简述类加载过程 date: 2019-03-13 10:06:10 categories: Java虚拟机 tags: 类加载机制 类加载机制(一):简述类加载过程 引言 Java源文件经过编译之后,生成了一连串的16...
  • JAVA类加载机制JAVA类加载类加载层次关系 类加载机制的特性JAVA类加载机制JAVA类加载器java类加载器负责把一个一个编译好的class文件装入内存中,并为其创建对应的java.lang.Class对象。java中有如下几种类加载器...
  • 浅谈类加载器和类加载过程

    千次阅读 2021-01-16 22:00:06
    类加载器的作用是将类的字节码文件加载...类加载过程 类的加载过程分三步: 加载 -> 链接(验证 -> 准备 -> 解析) -> 初始化 加载阶段(Loading): 链接阶段(Linking): 初始化阶段(Linking): ...
  • weblogic类加载过程简述weblogic类加载过程简述weblogic类加载过程简述weblogic类加载过程简述weblogic类加载过程简述weblogic类加载过程简述
  • java类加载过程

    千次阅读 2019-01-27 11:55:36
    根据冯.诺依曼定义的计算机模型,任何程序都需要加载到内存才能...类加载过程 类加载是一个将.class字节码文件实例化成Class对象并进行相关初始化的过程。 java的类加载是一个运行时核心基础模块,主要是在启动之初...
  • JVM类加载过程.pptx

    2021-05-07 15:16:58
    JVM类加载过程
  • 一、为什么要使用类加载器? Java语言里,类加载都是在程序运行期间完成的,这种策略虽然会令类加载时稍微增加一些性能开销,但是会给java应用程序提供高度的灵活性。例如: 1.编写一个面向接口的应用程序,可能等到...
  • 主要介绍了Java中类加载过程全面解析,具有一定参考价值,需要的朋友可以了解下。
  • java类加载流程

    2017-03-02 18:03:02
    父子类加载过程: 父类---->子类 类加载过程: 静态属性、静态方法声明----->静态属性赋值、静态块 实例化过程: 普通属性、普通方法声明----->普通属性赋值、构造块---->构造方法中的代码 如果在类加载过程中...
  • 首先明确“加载”是“类加载”的一个过程,不要混淆。加载过程中,虚拟机需要完成下列三个事情: 通过一个类的全限定名获取定义此类的二进制字节流; 将这个字节流所代表的静态存储结构转化为方法区运行时的数据...
  • Java类加载器(Java Classloader)是Java运行时环境(Java Runtime Environment)的一部分,负责动态加载Java类到Java虚拟机的内存空间中。类通常是按需加载,即第一次使用该类时才加载。 ...
  • 类加载流程-01

    万次阅读 2019-03-01 16:05:11
    从本文开始讲述类加载过程,在这里先解释一下类加载的时机是什么? 此时可以分为2种情况: 主动引用 被动引用 类的主动引用指的是: new一个类的对象 调用类的静态成员(除了final常量)和静态方法 使用java.lang....
  • 面试官:请你谈谈Java的类加载过程

    万次阅读 多人点赞 2018-02-01 00:08:28
    刚刚走出校门的应届毕业生,如果在去寻求一份Java开发的工作时,你的面试官很有可能一边看着你的简历,一边漫不经心地问你:了解过Java类的加载过程吗?...今天,小编就Java类加载过程这个问题,抛砖引玉,说一下...
  • 类加载过程和类加载器

    千次阅读 2018-03-05 22:03:16
    类加载过程 和其他语言一样,java编译器同样能够将.java文件编译成.class,但是对于JVM来讲,它并不关心,是哪种语言经过编译形成的。 JVM类加载工作原理:就是把类的class文件加载到内存中,并对数据进行校验、...
  • 图解JVM类加载机制与类加载过程

    千次阅读 2017-03-01 15:51:25
    一、为什么说Jabalpur语言是跨平台的二、Java虚拟机启动、加载类过程分析三、类加载器有哪些?其组织结构是怎样的?四、双亲加载模型的逻辑和底层代码实现是怎样的?五、类加载器与Class 实例的关系六、线程上下文...
  • 主要介绍了JVM的类加载过程以及双亲委派模型详解,类加载器就是根据指定全限定名称将 class 文件加载到 JVM 内存,然后再转化为 class 对象。,需要的朋友可以参考下
  • 简述类加载过程

    2020-02-29 14:01:53
    3. 类加载的总体流程3.1 加载过程3.2 验证过程3.3 准备过程3.4 解析过程3.5 初始化过程 < hr/> 1. 什么是类加载 1.1 类加载的五大步骤 2. 什么时候触发类加载? 3. 类加载的总体流程 3.1 加载过程 3.2 验证...
  • JVM—类加载过程学习

    2020-12-22 07:34:00
    1 类加载过程图解   系统加载Class类型的文件主要是:加载->连接->初始化,其中连接分为:验证->准备->解析;其实,整个生命周期是7步,类从被加载到虚拟机内存中开始,到卸载出内存为止,分为:加载->验证->准备...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 890,611
精华内容 356,244
关键字:

类加载过程