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

JVM类加载机制

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

JVM类加载机制

加载流程
  • C++创建Java虚拟机
  • 并创建引导类加载器实例
  • 创建JVM启动器sun.msi.Launcher
  • getLauncher()创建Launcher实例
  • getClassLoad()创建AppClassLoader
  • loadClass("类路径")将类加载进内存
  • 执行main方法XXX.main()
  • 运行结束,JVM销毁

类加载的过程

加载-->验证-->准备-->解析-->初始化

加载

加载编译后的class文件到内存当中

验证

校验编译后的文件格式,是否符合规范

准备

给静态变量分配内存并赋默认值

解析

符号引用

任何形式的字面量,如java中的方法、符号

直接引用
  • 直接指向目标的指针
  • 相对偏移量
  • 一个能间接定位到目标的句柄(虚拟地址)

动态链接

在程序运行时,将一些符号引用替换为直接引用

静态链接

在class文件编译时,将一些静态方法直接替换为直接引用(直接指向内存中的地址)

初始化

对静态变量赋初始值,并执行静态代码块

java中的类加载器

引导类加载器:主要负责加载jdk的位于jre下的lib目录下的核心类库

扩展类加载器:主要负责加载jdk的位于jre下的lib目录下的ext扩展目录

应用类加载器:主要负责加载自己应用中classpath路径下的类包

自定义加载器:主要负责加载用户自定义路径下的类包

双亲委派机制

在一个类被加载时,必然是由AppClassLoader先开始,因为在初始化Launcher的时候,得到的ClassLoader类型的对象是AppClassLoader

public class Launcher {
    private static URLStreamHandlerFactory factory = new Launcher.Factory();
    private static Launcher launcher = new Launcher();
    private static String bootClassPath = System.getProperty("sun.boot.class.path");
    private ClassLoader loader;
    private static URLStreamHandler fileHandler;
    //1.第一步实例化
    public static Launcher getLauncher() {
        return launcher;
    }

    public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }

        try {  //2.第二步,得到一个ClassLoader
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }

源码体现

protected Class loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // 1.会检查类是否已经被加载
        Class c = findLoadedClass(name);
        //若没有被加载
        if (c == null) {
            long t0 = System.nanoTime();
            try {//2.则调用其父类加载器(扩展类加载器)的方法   
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else { //3.若扩展类加载器不存在,则调用引导类加载器
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
            }   //4.若都加载不到则由自己加载                                                      if (c == null) {
            long t1 = System.nanoTime();
            c = findClass(name);
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);      sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
    }
}
if (resolve) {
    resolveClass(c);
}
return c;

双亲委派过程中类加载流程
  1. 由AppClassLoader调用父类ClassLoader的loadClass方法进行加载
  2. 检查是否有加载过,若有,直接返回;若无,则调用扩展类加载器进行加载
  3. 若扩展类加载器不存在,则由引导类加载器进行加载
  4. 若父类加载器都失败,则由应用程序加载器自己进行加载
双亲委派机制的作用
  • 实现了沙箱安全机制:避免核心类库被随意修改,自己写的类似java.lang.String.class类不会被加载。
  • 使得类不会被重复加载:当父类的加载器已经加载该类,子类的ClassLoader就没有必要再加载,保证被加载类的唯一性

全盘委托机制

即当前类依赖了其他的类对象,那么这个依赖的类也会有加载当前类的类加载器一起加载

自定义类加载器

从ClassLoader的源码可知,双亲委派机制在实现时调用的是它内部的loadClass()方法来作为加载的入口,通过findClass()方法来加载应用程序中自己写的类;所以要创建自定义的类加载器,需要:

  1. 实现ClassLoader类
  2. 重写loadClass方法中调用的findClass方法

public MyClassLoader(String classPath){
        this.classPath = classPath;
    }
    protected  Class findClass(String name) throws  ClassNotFoundException {
        try {
            byte[] data = loadByte(name);
            //本地方法,将一个字节数组转为Class对象,这个字节数组是class文件读取后最终的字节数组
            return defineClass(name,data,0,data.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
   
    private byte[] loadByte(String name) throws Exception{
        name = name.replaceAll("\.","/");
        FileInputStream fis = new FileInputStream(classPath + "/"+name+".class");
        //一次读取多个字节,若是本地加载则无问题;若是网络操作,可能会因为通讯问题导致得到的字节数有遗漏或者为0
        int len = fis.available();
        byte[] data = new byte[len];
        fis.read(data);
        fis.close();
        return  data;

   

测试类

            //1.初始化自定义类加载器,会先初始化父类ClassLoader,其中会把自定义加载器的父类加载器设置为APPClassLoader
            //加载自定义的代码路径
            MyClassLoader classLoader = new MyClassLoader("D:/test");
            //获得Class对象
            Class clazz = classLoader.loadClass("com.tuling.jvm.User1");
            Object obj = clazz.newInstance();
            Method method = clazz.getDeclaredMethod("sout", null);
            method.invoke(obj, null);
            System.out.println(clazz.getClassLoader().getClass().getName());

打破双亲委派机制

已知双亲委派的实现是在类加载的时候体现的,因此,若是要打破该机制;就需要重写ClassLoader类中的loadC方法,改变其中的类加载方式。

在之前的自定义类加载器类中重写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);
            if (c == null) {
                long t0 = System.nanoTime();
                    long t1 = System.nanoTime();
                    c = findClass(name);
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

Tomcat打破双亲委派机制

Tomcat作为一个web容器,要让多个应用都能运行起来需要什么?

  • 应用依赖的不同版本的类库,应该独立且隔离。
  • 应用依赖的相同版本的类库,应该共享。
  • web容器依赖的类库和应用依赖的类库,应该独立且隔离
  • web容器中的jsp支持修改,但jsp也会编译为class文件,所以web容器应该支持jsp的热部署

Tomcat为何不能使用默认的双亲委派机制

  • 双亲委派机制保证了相同路径在的类只会被加载一次,那么多应用下就无法加载不同版本的类库。
Tomcat自定义加载器

tomcat的几个主要类加载器:

  • commonLoader:Tomcat最基本的类加载器,加载路径中的class,可以被Tomcat容器本身以及各个Webapp访问;
  • catalinaLoader:Tomcat容器私有的类加载器,加载路径中的class对于Webapp不可见;
  • sharedLoader:各个Webapp共享的类加载器,加载路径中的class对于所有 Webapp可见,但是对于Tomcat容器不可见;
  • WebappClassLoader:各个Webapp私有的类加载器,加载路径中的class只对当前 Webapp可见,比如加载war包里相关的类,每个war包应用都有自己的WebappClassLoader,实现相互隔离,比如不同war包应用引入了不同的spring版本,这样实现就能加载各自的spring版本;

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

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

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