栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【面试必问】分析JVM的类加载过程

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【面试必问】分析JVM的类加载过程

目录
  • 一、简介
  • 二、类加载流程
    • 2.1 加载 Loading
      • 2.1 1类加载器 ClassLoader
      • 2.1.2 为什么要对类加载进行分层?
      • 2.1.3 双亲委派机制(父类委托)
      • 2.1.4 自定义累加载器
      • 2.1.5打破双亲委派机制
    • 2.2 连接 Linking
      • 2.2.1 校验 Verification
      • 2.2.2 准备 Preparation
      • 2.2.3 解析 Resolution
    • 2.3 初始化 Initialization
  • 三、总结 对象的创建过程

一、简介

Oracle官网:https://docs.oracle.com/javase/specs/index.html

点击Java虚拟机规范 HTML :

通过这个JVM虚拟机规范我们可以了解到:class字节码文件的格式、类加载过程。

首先我们编写的Java源码(.java)文件,经过编译器 被编译为字节码(.class)文件,通过类加载器加载(Loading)到JVM中,然后经过 连接(Linking)最后初始化(Initialization)

二、类加载流程 2.1 加载 Loading

加载:通过一个类的全限定名获取定义此类的二进制字节流(字节码文件)。所以这个动作通过类加载器完成。
类加载器会将类的二进制字节流加载到JVM中,并创建出代表这个类的java.lang.Class对象。

Java虚拟机对class文件采用的是按需加载的方式,也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时,Java虚拟机采用的是双亲委派模式,即把请求交由父类处理,它是一种任务委派模式。

2.1 1类加载器 ClassLoader

在JVM中将ClassLoader进行了分层,一共有四类:

  1. Bootstrap ClassLoader 启动类加载器,加载 /jre/lib public class Code01_ClassLoaderScope { public static void main(String[] args) { String boot = System.getProperty("sun.boot.class.path"); System.out.println(boot.replaceAll(":","n")); System.out.println("-------------------------"); String ext = System.getProperty("java.ext.dirs"); System.out.println(ext.replaceAll(":","n")); System.out.println("-------------------------"); String app = System.getProperty("java.class.path"); System.out.println(app.replaceAll(":","n")); } } 2.1.2 为什么要对类加载进行分层?

    如果自定义了一个java.lang.String类,但是在加载自定义String类的时候会率先使用引导类加载器加载,而引导类加载器在加载的过程中会先加载jdk自带的文件(rt.jar报中java/lang/String.class)这样可以保证对java核心源代码的保护。

    2.1.3 双亲委派机制(父类委托)

    双亲委派 机制加载Class的具体过程是:

    1. ClassLoader先判断该Class是否已加载,如果已加载,则返回Class对象;如果没有则委托 给父类加载器。

    2. 父类加载器判断是否加载过该Class,如果已加载,则返回Class对象;如果没有则委托给 祖父类加载器。

    3. 依此类推,直到始祖类加载器(引用类加载器)。

    4. 始祖类加载器判断是否加载过该Class,如果已加载,则返回Class对象;如果没有则尝试 从其对应的类路径下寻找class字节码文件并载入。如果载入成功,则返回Class对象;如果 载入失败,则委托给始祖类加载器的子类加载器。

    5. 始祖类加载器的子类加载器尝试从其对应的类路径下寻找class字节码文件并载入。如果载 入成功,则返回Class对象;如果载入失败,则委托给始祖类加载器的孙类加载器。

    6. 依此类推,直到源ClassLoader。

    7. 源ClassLoader尝试从其对应的类路径下寻找class字节码文件并载入。如果载入成功,则 返回Class对象;如果载入失败,源ClassLoader不会再委托其子类加载器,而是抛出异 常。

    缓存机制,缓存机制将会保证所有加载过的Class都将在内存中缓存,当程序中需要使用某个 Class时,类加载器先从内存的缓存区寻找该Class,只有缓存区不存在,系统才会读取该类对应 的二进制数据,并将其转换成Class对象,存入缓存区。这就是为什么修改了Class后,必须重启 JVM,程序的修改才会生效.对于一个类加载器实例来说,相同全名的类只加载一次,即 loadClass方法不会被重复调用。

    2.1.4 自定义累加载器

    自定义类加载器,重写findClass()方法

    package com.lsh.class01;
    
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    
    
    public class MyClassLoader extends ClassLoader {
        @Override
        protected Class findClass(String name) throws ClassNotFoundException {
            System.out.println("执行了MyClassLoader的findClass()方法");
    //        String s = "/Users/LiuShihao/IdeaProjects/jvm-demo/target/classes/" + name.replaceAll("\.", "/")+".class";
            String s = "/Users/LiuShihao/Desktop/Demo.class";
    
            System.out.println("name:"+name);
            System.out.println(s);
    
            File file = new File(s);
            if (!file.exists()){
                System.out.println("File Not Fount:"+name);
                return super.findClass(name);
            }
            try {
                FileInputStream fis = new FileInputStream(file);
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                byte[] bytes = new byte[fis.available()];
                int length = 0;
                if ((length = fis.read(bytes))!= -1){
                    bos.write(bytes,0,length);
                }
                System.out.println("____"+name);
                return defineClass(name,bos.toByteArray(),0,bos.toByteArray().length);
            }catch (Exception e){
                e.printStackTrace();
            }
            return super.findClass(name);
        }
    
        public static void main(String[] args) throws ClassNotFoundException {
            MyClassLoader myClassLoader = new MyClassLoader();
    //        Class aClass = myClassLoader.loadClass("com.lsh.class01.Demo");
            Class aClass = myClassLoader.loadClass("Demo");
            System.out.println(aClass.getClassLoader());
    
            myClassLoader = new MyClassLoader();
    //        Class aClass1 = myClassLoader.loadClass("com.lsh.class01.Demo");
            Class aClass1 = myClassLoader.loadClass("Demo");
            System.out.println(aClass.getClassLoader());
            System.out.println(aClass == aClass1);//判断加载出的类是否是同一个类  由于存在双亲委派机制,可以保证类在JVM中的唯一性
    //        Demo o = (Demo)aClass.newInstance();
    //        o.m();
    //        Class aClass1 = myClassLoader.loadClass("com.lsh.class01.Demo");
        }
    
    }
    
    
    2.1.5打破双亲委派机制

    如果要打破双亲委派机制,则需要自定义类加载器,并且重写loadClass()方法。

    通过类加载器可以保证类在jvm中的唯一性。而重写loadClass(),打破了双亲委派机制,则无法保证JVM中类的唯一性。

    package com.lsh.class01;
    
    import java.io.File;
    import java.io.FileInputStream;
    
    
    public class MyClassLoadBroker extends ClassLoader  {
    
        
        @Override
        public Class loadClass(String name) throws ClassNotFoundException {
            String s = "/Users/LiuShihao/IdeaProjects/jvm-demo/target/classes/" + name.replaceAll("\.", "/")+".class";
            File file = new File(s);
            System.out.println("加载:"+name);
            if (!file.exists()){
                System.out.println("File Not Found:"+name);
                return super.loadClass(name);
            }
            try {
                FileInputStream fis = new FileInputStream(file);
                byte[] bytes = new byte[fis.available()];
                fis.read(bytes);
                return defineClass(name,bytes,0,bytes.length);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return super.loadClass(name);
    
        }
    
        public static void main(String[] args)throws Exception {
            MyClassLoadBroker myClassLoadBroker = new MyClassLoadBroker();
            Class aClass1 = myClassLoadBroker.loadClass("com.lsh.class01.HelloWorld");
            //如果一个类已经被一个类加载器加载到内存中,此时再用同一个类加载进行加载则会抛异常 Exception in thread "main" java.lang.LinkageError: loader (instance of  com/lsh/class01/MyClassLoadBroker): attempted  duplicate class definition for name: "com/lsh/class01/HelloWorld"
            //尝试重复的名称类定义 :attempted  duplicate class definition for name
    //        Class aClass3 = myClassLoadBroker.loadClass("com.lsh.class01.HelloWorld");
    //        System.out.println(aClass1 == aClass3);
    
            System.out.println(aClass1.getClass().getClassLoader());
            System.out.println(aClass1.getClassLoader());
    
            myClassLoadBroker = new MyClassLoadBroker();
            Class aClass2 = myClassLoadBroker.loadClass("com.lsh.class01.HelloWorld");
            System.out.println(""+aClass1.getClassLoader());
            System.out.println(aClass2 == aClass1);
            
    
        }
    }
    
    
    2.2 连接 Linking

    连接又分为3个部分:

    1. 校验 Verification
    2. 准备 Preparation
    3. 解析 Resolution
    2.2.1 校验 Verification

    无论是什么语言,只要可以被编译为class文件,就可以被JVM执行,所以Java可以跨平台执行。
    Class文件有严格的格式,包含:magic、minor_version、major_version、constant_pool_count、constant_pool、access_flags等类信息。

    ClassFile {
        u4             magic;
        u2             minor_version;  
        u2             major_version; 
        u2             constant_pool_count; 
        cp_info        constant_pool[constant_pool_count-1];   
        u2             access_flags;   
        u2             this_class;  
        u2             super_class; 
        u2             interfaces_count;  
        u2             interfaces[interfaces_count];  
        u2             fields_count;  
        field_info     fields[fields_count];  
        u2             methods_count;
        method_info    methods[methods_count];   
        u2             attributes_count;
        attribute_info attributes[attributes_count];
    }
    

    例如:我们以16进制打开一个class文件:
    可以看到字节码文件固定是cafe babe 开头,之后是版本信息 0034 转换为10进制是 52,代表的就是jdk1.8。之后是常量池信息等等。
    ’
    所以 JVM需要校验字节码格式、验证类信息。例如是否以cafebabe开头、final修饰的类不能被继承等。

    2.2.2 准备 Preparation

    在准备阶段会对类的静态成员(static修饰的)变量分配内存空间,并赋默认值。

    各种类型的默认值:

    • 这里不包含用final修饰的static,因为final在编译的时候就会分配了,准备阶段会显式初始化;
    • 这里不会为实例变量(也就是没加static)分配初始化,类变量会分配在方法区中,而实例变量 是会随着对象一起分配到Java堆中。
    2.2.3 解析 Resolution

    解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。
    直接引用是与虚拟机内存布局实现相关,同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同,如果有了直接引用,那引用的目标必定存在内存中。

    解析之后会对解析结果进行缓存。

    2.3 初始化 Initialization

    初始化阶段是执行类构造器方法的过程,此时为静态成员(static修饰的)变量赋初始值。
    如果类的直接父类还没有被初始化,则先初始化其直接父类,即初始化某个类的子类,则其父类也会被初始化

    三、总结 对象的创建过程
    1. new(),在常量池中定位到类的符号引用
    2. 检查该类是否已经被加载
      1. 如果没有被加载,则进行加载、连接(校验、准备、解析)、初始化阶段。
    3. 申请分配内存,并为成员变量赋默认值
      1. 优先在栈上分配
      2. 如果对象很大,则直接进入老年代Old
      3. 线程本地分配(TLAB)
      4. Eden(堆内存 新生代)
      5. Survivor(堆内存 新生代)
      6. Old (堆内存 老年代)
    4. 调用类的构造方法,为成员变量赋初始值。

    注意:Java中对象是按需加载的,只有在用的的时候才进行加载,

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/955840.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号