JVM笔记(一):java和Tomcat类加载机制

文章部分来源图灵学院,部分来源网络博文,因为链接具体找不到,这里深感抱歉,如果介意,请留言
知乎:https://zhuanlan.zhihu.com/p/397669677

JVM加载

当我们用java命令运行某个类的main函数启动程序时,首先需要通过类加载器把主类加载到jvm中。类似流程图如下。


加载过程图

loadClass加载步骤

类全生命周期:加载>>验证>>准备>>解析>>初始化>>使用>>卸载。

加载周期

加载:在硬盘上查找并通过IO兑入字节码文件,使用到类时才会加载,例如调用类的main方法,new对象等等,在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象,放在堆中,作为访问这个类在方法区中类元数据的各个数据的接口。
验证:校验字节码文件的正确性。如:文件格式的验证,元数据的验证,字节码的验证,符号引用的验证。
准备:给类的静态变量分配内存,并赋予默认值,此处给默认值,不一定是我们程序中赋予的值。如果被final修饰,在编译的时候会给属性添加ConstantValue属性,准备阶段直接完成赋值,即没有赋初值这一步

解析:将符号引用替换为直接引用,该阶段会把一些静态方法(符号引用,比如main()方法)替换为指向数据所存内存的指针或者句柄等(直接引用),这是所谓的静态链接过程(类加载期间完成),动态链接是在程序运行期间完成的,将符号引用替换为直接引用(// TODO 待补充),解析后的信息存储在ConstantPoolCache类实例中
初始化:对类的静态变量初始化为指定的值,执行静态代码块,比如:initData 的666值是此时才赋予的。构造放在在静态代码块之后。

publicstaticfinalintinitData=666;
v2

类被加载到方法区中后,主要包含运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。
类加载器的引用:这个类到 类加载器实例 的引用。
对应class实例的引用:类加载器在加载类信息放到方法区中后,会创建一个对应的Class类型的对象实例放到堆(Heap)中,作为开发人员访问方法区中类定义的入口和切入点。
注意:主类在运行过程中如果使用到其他类,会逐步加载这些列。jar包或者war包里的类不是一次性全部加载的,是使用到时才加载。代码示例如下:

public class TestDynamicLoad {
    static {
        System.out.println("*************load TestDynamicLoad************");
    }

    public static void main(String[] args) {
        new A();
        System.out.println("*************load test************");
        B b = null; //B不会加载,除非这里执行 new B()
    }

}

class A {
    static {
        System.out.println("*************load A************");
    }

    public A() {
        System.out.println("*************initial A************");
    }
}

class B {
    static {
        System.out.println("*************load B************");
    }

    public B() {
        System.out.println("*************initial B************");
    }
}

结果:
*************load TestDynamicLoad************
*************load A************
*************initial A************
*************load test************

类加载机制

类加载过程主要是通过类加载器来实现的,java里有如下几种类加载器。

  • 引导类加载器(bootstrapLoader):负责加载支撑JVM运行的位于JRE的lib目录下的核心类库,比如:rt.jar、charsets.jar等
  • 扩展类加载器(ExtClassLoader):负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包
  • 应用程序类加载器(AppClassLoader):负责加载ClassPath路径下的类包,主要就是加载自己写的那些类。自定义加载器:负责加载用户自定义路径下的类包。

类加载器初始化过程

由上面的加载过程图可知,JVM启动,实例sun.misc.Launcher类,而sun.misc.Launcher构造方法内部,创建了两个类加载器,分别是sun.misc.Launcher.ExtClassLoader(扩展类加载器)和sun.misc.Launcher.AppClassLoader(应用类加载器)。

JVM会默认调用Launcher中的getClassLoader()方法,返回的加载器会是AppClassLoader来加载我们的应用程序。代码截取

//Launcher的构造方法
public Launcher() {
 Launcher.ExtClassLoader var1;
 try {
 //构造扩展类加载器,在构造的过程中将其父加载器设置为null
 var1 = Launcher.ExtClassLoader.getExtClassLoader();
 } catch (IOException var10) {
 throw new InternalError("Could not create extension class loader", var10);
 }

 try {
 //构造应用类加载器,在构造的过程中将其父加载器设置为ExtClassLoader,
 //Launcher的loader属性值是AppClassLoader,我们一般都是用这个类加载器来加载我们自
己写的应用程序
 this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
 } catch (IOException var9) {
 throw new InternalError("Could not create application class loader", var9);
 }

 Thread.currentThread().setContextClassLoader(this.loader);
 String var2 = System.getProperty("java.security.manager");
 。。。 。。。 //省略一些不需关注代码

}


 public ExtClassLoader(File[] var1) throws IOException {
  // Launcher.ExtClassLoader.getExtClassLoader(); 实例化会走到地方,他父加载器传的是null
  super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
  SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
}

双亲委派机制

JVM类加载器是有亲子层级结构的,如下图:


双亲委派图

这里类加载其实就是一个双亲委派机制,加载某个类时,launcher的getClassLoader会给出appClassLoader这个加载器,调用其最上层抽象ClassLoader的loadClass方法,其流程是会先找自己有没有加载过(并不是加载)这个类,如果有直接返回,如果没有,则委托父加载器寻找目标类,而此时父加载器(扩展类加载器)同样是实现ClassLoader的类,同样走loadClass方法,逻辑也是找自身是否加载过此类,如果没有,则继续委托其父加载器;如果依然找不到目标类,则在自己的类加载路径中查找并载入目标类。

比如我们的Math类,最先会找应用程序类加载器加载,应用程序类加载器会先委托扩展类加载 器加载,扩展类加载器再委托引导类加载器,顶层引导类加载器在自己的类加载路径里找了半天没找到Math类,则向下退回加载Math类的请求,扩展类加载器收到回复就自己加载,在自己的类加载路径里找了半天也没找到Math类,又向下退回Math类的加载请求给应用程序类加载器,应用程序类加载器于是在自己的类加载路径里找Math类,结果找到了就自己加载了。

//ClassLoader的loadClass方法,里面实现了双亲委派机制
protected Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            //  // 检查当前类加载器是否已经加载了该类
            Class c = findLoadedClass(name);
            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
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    //都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类
                    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装载一个类时,除非显示的使用另一个ClassLoader,该类所有依赖及引用的类也有这个ClassLoader一次载入完毕。(因为正常情况下,依赖和引用类是只有在使用的时候才加载的。)

类关系图

classLoader类继承图

自定义类加载器

自定义类加载器只需要继承java.lang.ClassLoader类,该类由两个核心方法,一个是loadClass(String,boolean),实现了双亲委派机制,还有一个是findClass,默认实现是空方法,所以我们自定义类加载器主要是重写findClass方法(app和ext因为都是继承URLClassLoader,此方法在URLClassLoader中实现了)。

package com.tuling.jvm;

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Method;

/**
 * @Description: 自定义类加载器
 * @ClassName: MyClassLoaderTest
 * @Author: 
 * @Date: 2021/8/11 0:42
 **/
public class MyClassLoaderTest {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;

        }

        protected Class findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                //defineClass将一个字节数组转为Class对象,这个字节数组是class文件读取后最终的字节 数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }
    }

    public static void main(String args[]) throws Exception {
        //初始化自定义类加载器,会先初始化父类ClassLoader,其中会把自定义类加载器的父加载 器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:"+ File.separator+"program_test");
        //D盘创建 test/com/tuling/jvm 几级目录,将User类的复制类User1.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());
    }
}

打破双亲委派机制

package com.tuling.jvm;

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Method;

/**
 * @Description: 双亲委派和反
 * @ClassName: MyClassLoaderTest
 * @Author: 
 * @Date: 2021/8/11 0:42
 **/
public class MyClassLoaderTest {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;

        }

        protected Class findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                //defineClass将一个字节数组转为Class对象,这个字节数组是class文件读取后最终的字节 数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        /**
         * 重写类加载方法,实现自己的加载逻辑,不委派给双亲加载
         *
         * @param name
         * @param resolve
         * @return
         * @throws ClassNotFoundException
         */
        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) {
                    // 特定类打破 这里的判断和实现方式可以更换,思想是这样
                    if (name.startsWith("com.tuling.jvm")) {
                        c = findClass(name);
                    } else {
                        c = super.loadClass(name, false);
                    }
                }

                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }
    }


    public static void main(String args[]) throws Exception {
        //初始化自定义类加载器,会先初始化父类ClassLoader,其中会把自定义类加载器的父加载 器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:" + File.separator + "program_test");
        //D盘创建 test/com/tuling/jvm 几级目录,将User类的复制类User1.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());
    }
}

Tomcat类加载器

思考:tomcat是web容器,他需要解决什么问题?

  1. 一个web容器可能需要部署两个及以上的应用程序,不同的应用程序可能会依赖同一个第三方类库的不同版本,不能要求同一个类库在同一个服务器只有一份,因此要保证每个应用程序的类库都是独立的,保证相互隔离。
  2. 部署在同一个web容器中的相同的类库相同的版本可以共享。否则,如果服务器有10个应用程序,那么要有10分相同的类库加载进入虚拟机
  3. web容器也有自己依赖的类库,不能与应用程序的类库混淆,基于安全考虑,应该让容器的类库和程序的类库隔离开来。
  4. web容器要支持JSP的修改,jsp文件最终也要编译成class文件才能在虚拟机中运行,但是jsp修改频繁,需要热加载。

为了解决以上问题,tomcat是如何实现类加载机制的?

tomcat双亲委派类型图
  • commonClassLoader:tomcat最基本的类加载器,加载路径中的class可以被Tomcat容器本身以及各个WebApp访问;
  • catalinaClassLoader:tomcat容器私有的类加载器,加载路径中的class对于WebApp不可见。
  • sharedClassLoader:各个WebApp共享的类加载器,加载路径中的class对于所有WebApp可见,但是对于Tomcat容器不可见
  • WebAppClassLoader:各个WebApp私有的类加载器,加载路径中的class只对于当前WebApp可见,比如加载war包里的相关类,每个war包应用都有自己的WebAppClassLoader,实现相互隔离,比如不同war包应用引入了不同的spring版本,这样实现就能加载给咱的spring版本。webappClassLoader加载自己的目录下的class文件,不会传递给父类加载器,打破了双亲委派机制
    委派关系:
  1. CommonClassLoader能加载的类都可以被Catalina ClassLoader和SharedClassLoader使用,从而实现了公有类库的共用,而CatalinaClassLoader和Shared ClassLoader自己能加载的类则与对方相互隔离。
  2. WebAppClassLoader可以使用SharedClassLoader加载到的类,但WebAppClassLoader实例之间相互隔离。
  3. JasperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件,它出现的目的就是为了被丢弃:当Web容器检测到JSP文件被修改时,会替换掉目前的JasperLoader的实例,并通过再建立一个新的Jsp类加载器来实现JSP文件的HotSwap功能。

加载类关系

tomcatclassloader类继承关系

注意:同一个JVM内,两个相同包名和类名的类对象可以共存,因为他们的类加载器可以不一样,所以看两个类对象是否是同一个,除了看类的包名和类名是否都相同之外,还需要他们的类加载器也是同一个才能认为他们是同一个。

课后小问题

1.为什么先执行静态代码块,后执行构造方法?

答:因为在初始化的时候,会执行静态代码块的内容,而构造方法是在new对象的时候调用的。这也正证实加载并不会new一个完整对象出来。而仅仅只会有一个class对象到堆中。

2.为什么要设计双亲委派机制?

答:(1)沙箱安全机制:自己写的java.lang.String.class类不会被加载,这样便可以防止核心API库被随意篡改。
(2)避免类的重复加载:当父亲已经加载了该类时,就没有必要子Classloader在加载一次,保证被加载的类的唯一性。

3.Tomcat如果使用默认的双亲委派类加载机制行不行? 为什么?

答:不行。这就涉及到Tomcat要解决的问题。

  • 如果使用默认的类加载器机制,那么是无法加载两个相同类库的不同版本的,默认的类加载器是不管类的版本,只根据全名查找,且只有一份。
  • 如何实现jsp的热加载问题,因为jsp会编译成calss文件,如果修改了jsp,但是类名并没有变,类加载器会直接取方法区中的已存在的信息,修改的并不会被加载到。所以,Tomcat的处理办法是,当你修改jsp,他会卸载掉这个jsp的类加载器,重新创建新的类加载器,加载jsp文件。

4.Tomcat打破了类加载机制,是否可以恶意定义HashMap?是否安全

答:不可以,因为上层类加载器依然没有变,根据列关系图,都会走到secureClassLoader,做安全校验。

你可能感兴趣的:(JVM笔记(一):java和Tomcat类加载机制)