JVM类加载过程详细分析

双亲委派加载模型

为什么需要双亲委派加载模型

主要是为了安全,避免用户恶意加载破坏JVM正常运行的字节码文件,比如说加载一个自己写的java.util.HashMap.class。这样就有可能造成包冲突问题。

类加载器种类

  • 启动类加载器:用于加载jdkrt.jar的字节码文件
  • 扩展类加载器:用于加载jdk/jre/lib/ext文件夹下的字节码文件
  • 应用程序类加载器:加载classPath下的字节码文件
  • 自定义类加载器:用户在程序中自己定义的加载器

源码分析

1、ClassLoader.loadClass()

    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
    	// 加锁
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            // 如果这个Class对象还没有被加载,下面就准备加载
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                	// 查看当前类加载器有没有父类加载器
                    if (parent != null) {
                    	// 父类加载器来加载字节码文件
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }
				// 如果父类加载器也没有加载这个Class对象,就由自己来加载
                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

不遵守双亲委派加载模型的例子

双亲委派加载模型仅仅是一个约定,后面实现类加载器时,是可以不遵守这个约定。ClassLoader是在JDK1.0的时候就设计好的,而双亲委派加载模型在JDK1.2引入的。所以,有些机制是没有遵守这个约定的。比如:Service Provider Interface机制的JDBC就没有遵守这个约定。

1、为什么JDBC无法遵守这个约定?

JDBCSPI机制的一个例子,JDK定义了java.sql.Connection核心接口,后续MySQLOracle为其提供实现类。在运行中是通过java.sql.DriverManager来获取指定实现类的实例。这里需要明白三个问题:

  • java.sql.DriverManager是在rt.jar中,由核心类加载器加载的;
  • 第三方所提供Collection的实现类都是在classpath中;
  • 类中方法想加载新的字节码文件时,其初始类加载器就是当前这个类的定义类加载器;

也就是说当JVMjava.sql.DriverManager类的getConnection()方法中获取Collection实现类的字节码时,当前类的定义类加载器是启动类加载器,而按照约定启动类加载器是不允许加载classpath下的字节码。所以,JDBC就无法遵守这个约定。

2、JDBC是如何解决上面的问题的?

为了解决这个,java在线程中放入一个类加载器Thread.currentThread().getContextClassLoader();而这个类加载器可以是随意的。比如你想加载classpath包下的字节码文件,只需要设置当前线程的类加载器为应用程序类加载器即可。

JVM类加载过程

JVM本质的工作就是读取字节码文件、执行字节码文件中的指令。其中JVM将读取字节码文件的过程称为JVM类加载过程。

JVM读取的字节码文件将放在方法区里;

JVM类加载机制分为五个部分:加载、验证、准备、解析、初始化。如下图所示:

一、Loading:加载

这一步是将JVM外的字节码文件加载到JVM内部方法区中的Class对象。

JVM可以通过几种方式来加载外部的字节码文件?

  • 从本地读字节码文件;
  • 从网络读取字节码文件;
  • 通过动态生成的字节码文件;

初始类加载器和定义类加载器

由于双亲委派加载模型的存在,一个Class对象的初始类加载器initiating class loader和定义类加载器defining class loader有可能不是同一个。

  • 初始类加载器:它是指让JVM加载这个字节码文件
  • 定义类加载器:它是真正调用defineClass方法,将字节码转换成Class对象

java在判断instanceof时,只有类名、defining class loader都相等,才表示是同一个类的实例。

Class.getClassLoader()得到的是定义类加载器

相关实验代码

1、验证使用不同ClassLoader加载字节码文件

// 这种方法是不遵守双亲委派加载模型的约定
public class ClassLoaderLoading {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 这个Class对象是由当前方法的类加载器加载
        Class c1 = MiniJVM.class;
        Class c2 = new MyClassLoader().loadClass("com.github.hcsp.MiniJVM");
        // 使用c2创建一个MiniJVM实例
        Object o = c2.getConstructor().newInstance();
        System.out.println(o instanceof MiniJVM);
        MiniJVM demo = (MiniJVM) o;
    }

    private static class MyClassLoader extends ClassLoader {
        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            if (name.contains("MiniJVM")) {
                try {
                    byte[] bytes = Files.readAllBytes(new File("target/classes/com/github/hcsp/MiniJVM.class").toPath());
                    return defineClass(name, bytes, 0, bytes.length);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            } else {
                return super.loadClass(name);
            }
        }
    }
}

2、实现一个遵守双亲委派加载模型的类加载器

public class ClassLoaderLoading {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = MiniJVM.class;
        Class c2 = new MyClassLoader(ClassLoader.getSystemClassLoader()).loadClass("com.github.hcsp.MiniJVM");
        System.out.println("c2 = " + c2);
    }

    private static class MyClassLoader extends ClassLoader {
        public MyClassLoader(ClassLoader systemClassLoader) {
            super(systemClassLoader);
        }

        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            // 加载你想让这个类加载器加载的字节码文件
            if (name.contains("MiniJVM")) {
                try {
                    byte[] bytes = Files.readAllBytes(new File("target/classes/com/github/hcsp/MiniJVM.class").toPath());
                    return defineClass(name, bytes, 0, bytes.length);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            } else {
                // 其他的字节码文件交由父类加载器加载
                return super.loadClass(name);
            }
        }
    }
}

二、Linking:链接

当一个.java文件编译成.class文件时,里面含有一个符号引用,比如/java/utils/HashMapLinking是指将这符号引用与具体的class对象链接起来。

每个字节码结构都有一个运行时常量池,它会存储每个符号引用和所对应的具体对象,以此实现链接。

  • Verification:验证字节码的正确性
  • Preparation:为static成员赋默认初始值
  • Resolution:解析当前字节码里包含的其他符号引用

三、Initializing

执行初始化方法。比如下面的四个虚拟机指令:newgetstaticputstaticinvokestatic

原博客地址

原文地址:https://www.cnblogs.com/fourther/p/12687964.html

时间: 2024-11-09 02:28:59

JVM类加载过程详细分析的相关文章

JVM类加载过程

JVM类加载过程 类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载.验证.准备.解析.初始化.使用和卸载七个阶段.它们开始的顺序如下图所示: 其中类加载的过程包括了加载.验证.准备.解析.初始化五个阶段.在这五个阶段中,加载.验证.准备和初始化这四个阶段发生的顺序是确定的,而解析阶段则不一定,它在某些情况下可以在初始化阶段之后开始,这是为了支持Java语言的运行时绑定(也成为动态绑定或晚期绑定).另外注意这里的几个阶段是按顺序开始,而不是按顺序进行或完成,因为这些阶段通

JVM类加载过程及主动引用与被动引用

了解类加载全过程,有助于了解JVM运行过程,以及更深入了解java动态性(解热部署,动态加载),提高程序灵活性. 类加载全过程: JVM将class文件字节码文件加载到内存中,并对数据进行校验解析和初始化,最终形成可以直接使用的java类型的过程. 加载 将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区中的运行时数据结构,在堆中生成一个代表这个类的java.lang.Class对象,作为方法区类数据的访问入口. 链接 将Java类的二进制代码合并到JVM的运行状态之中的过程.

JVM类加载机制详解(一)JVM类加载过程

首先Throws(抛出)几个自己学习过程中一直疑惑的问题: 1.什么是类加载?什么时候进行类加载? 2.什么是类初始化?什么时候进行类初始化? 3.什么时候会为变量分配内存? 4.什么时候会为变量赋默认初值?什么时候会为变量赋程序设定的初值? 5.类加载器是什么? 6.如何编写一个自定义的类加载器? 首先,在代码编译后,就会生成JVM(Java虚拟机)能够识别的二进制字节流文件(*.class).而JVM把Class文件中的类描述数据从文件加载到内存,并对数据进行校验.转换解析.初始化,使这些数

JVM 类加载过程

类从加载到虚拟机到卸载,它的整个生命周期包括:加载(Loading),验证(Validation),准备(Preparation),解析(Resolution),初始化(Initialization),使用(Using)和卸载(Unloading).其中,验证.准备和解析部分被称为连接(Linking). 加载: 在加载阶段,虚拟机主要完成三件事: 1.通过一个类的全限定名来获取定义此类的二进制字节流. 2.将这个字节流所代表的静态存储结构转化为方法区域的运行时数据结构. 3.在Java堆中生成

面试必问:JVM类加载机制详细解析

前言 在Java面试中,简历上有写JVM(Java虚拟机)相关的东西,JVM的类加载机制基本是面试必问的知识点. 类的加载和卸载 JVM是虚拟机的一种,它的指令集语言是字节码,字节码构成的文件是class文件.平常我们写的Java文件,需要编译为class文件才能交给JVM运行.可以这么说:C语言代码——>二进制文件——>计算机硬件,就相当于Java代码——>字节码文件——>JVM.JVM将指定的class文件读取到内存里,并运行该class文件里的Java程序的过程,就称之为类的

Spark Shuffle过程详细分析

在MapReduce中shuffle和Spark的shuffle的过程有一些区别.这里做一下具体的介绍. Mapreduce的shuffle过程图解 Spark shuffle过程图解 注意:spark shuffle过程中没有分区和排序的过程,而且存储结果存储在内存中,所以速度要比mapreduce要快很多. 先就到这里吧,图解的说明应该比较清晰了.有问题欢迎留言

JVM 类加载过程、初始化、主动引用、被动引用、静态初始化块执行顺序

java JVM类加载过程图

原文地址:https://blog.51cto.com/14437184/2438707

JVM类加载续

上一篇理解了JVM类加载过程的第一个阶段,这篇来说说剩下的阶段:验证.准备.解析.初始化.需要注意的是,这些阶段(解析除外)只是按照这个顺序开始,但是执行的过程中可能存在交叉. 验证:就是要对加载的二进制流文件进行各种检查,很好理解. 准备:为类变量(static)分配内存并设置初始值,即所谓的"零值",但是不包括常量(final). 解析:将常量池的符号引用替换成直接引用,这个阶段发生时间没有明确规定,但是有具体限制:在符号引用被使用之前,必须被解析. 上述3个阶段合称连接阶段. 初