java jvm基础-类加载机制

jvm基础-类加载机制

1.类加载的顺序

public class Math {

    private static final Integer data=666;
     //静态的属于类资源优先加载
    static {
        System.out.println("===静态代码块加载===");
    }
    //构造器属于对象随着对象的创建而触发构造器
    public Math(){
        System.out.println("===类构造方法加载===");
    }
    //其次顺序是普通方法的加载
    public Integer count(){
        
        System.out.println("===计算方法加载=====");
        int a=1; int b=2;
        int c=a+b;
        return c;
    }

    public static void main(String[] args) {
        Math math=new Math();
        Integer count = math.count();
        System.out.println("计算结果为"+count);
    }
}

2.类加载编译的过程

3.类加载器加载类的过程

加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载
加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口

验证：校验字节码文件的正确性

准备：给类的静态变量分配内存，并赋予默认值

解析：将符号引用替换为直接引用，该阶段会把一些静态方法(符号引用，比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用，下节课会讲到动态链接

初始化：对类的静态变量初始化为指定的值，执行静态代码块

类被加载到方法区中后主要包含 运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。
类加载器的引用：这个类到类加载器实例的引用
对应class实例的引用：类加载器在加载类信息放到方法区中后，会创建一个对应的Class 类型的对象实例放到堆(Heap)中, 作为开发人员访问方法区中类定义的入口和切入点。

注意，主类在运行过程中如果使用到其它类，会逐步加载这些类。jar包或war包里的类不是一次性全部加载的，是使用到时才加载。

4.类加载器和双亲委派机制

上面的类加载过程主要是通过类加载器来实现的，Java里有如下几种类加载器

1.引导类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charsets.jar等.

2.扩展类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR 类包.

3.应用程序类加载器：负责加载ClassPath路径下的类包，主要就是加载你自己写的那 些类.

4.自定义加载器：负责加载用户自定义路径下的类包.

下面代码来展示三种不同的加载器

双亲委派机制原理图

双亲委派机制代码分析
classLoader.loadClass方法解析

    protected Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
        synchronized(this.getClassLoadingLock(var1)) {
            //再已经加载的内存文件中查找是否已经有这个类，有则直接返回
            Class var4 = this.findLoadedClass(var1);
            if (var4 == null) {
                long var5 = System.nanoTime();
                try {
                    //双亲委派机制代码
                    if (this.parent != null) {
                        //使用父类属性去加载到根加载器，因为根加载器java属性为null
                        var4 = this.parent.loadClass(var1, false);
                    } else {
                        //当为根加载器时走这个逻辑去bootstrap加载器中找是否有这个类有就返回
                        var4 = this.findBootstrapClassOrNull(var1);
                    }
                } catch (ClassNotFoundException var10) {
                }

                if (var4 == null) {
                    long var7 = System.nanoTime();
                    //URLCLassLoader的findClass方法其中涉及保护机制原理，以及c++代码查找当前类加载器的类并返回结果
                    var4 = this.findClass(var1);
                    PerfCounter.getParentDelegationTime().addTime(var7 - var5);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(var7);
                    PerfCounter.getFindClasses().increment();
                }
            }

            if (var2) {
                this.resolveClass(var4);
            }

            return var4;
        }
    }
   

演示代码了解双亲委派机制

public class MyClassLoader {

    static class MyClassLoaderOne extends ClassLoader{

        private final String classPath;



        protected MyClassLoaderOne(String classPath) {
            this.classPath=classPath;
        }

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

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            //将.转化为/
            try {
                byte[] data = loadByte(name);
                return defineClass(name,data,0,data.length);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }


        public static void main(String[] args) throws Exception {
            MyClassLoaderOne myClassLoaderOne=new MyClassLoaderOne("D:\\java\\code_workhouse\\jvm-project\\jvm-project");
            Class<?> aClass = myClassLoaderOne.loadClass("com.zhang.cn.User");
            Object o = aClass.newInstance();
            Method method = aClass.getDeclaredMethod("study",null);
            method.invoke(o);
            System.out.println(aClass.getClassLoader().getClass().getName());

        }
    }
}

如何打破双亲委派机制的思路