01 类加载机制解析一

最新推荐文章于 2022-05-04 10:31:38 发布

wyaoyao93

最新推荐文章于 2022-05-04 10:31:38 发布

阅读量189

点赞数

分类专栏： jvm

本文链接：https://blog.csdn.net/wyaoyao93/article/details/108351063

版权

jvm 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

1 类加载器初始化和加载类的过程

package study.wyy.jvm.classLoader;

import study.wyy.jvm.model.User;

public class Math {

    public static User user = new User();

    public static  int initData = 666;

    // 一个方法对应一个栈帧内存区域
    public int compute() {
        int a = 1;
        int b = 2;
        int c = (a + b) * 10;
        return c;
    }

    public static void main(String[] args) {
        Math math = new Math();
        math.compute();
    }
}

上面这个代码的大致过程就是如下：
在这里插入图片描述

其中loadClass的类加载过程有如下几步：
加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载

加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的 main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的 java.lang.Class对象，作为方法区这个类的各种数据的访问入口
验证：校验字节码文件的正确性
准备：给类的静态变量分配内存，并赋予默认值
- 比如int的默认值就是0，bool的默认值就是false，比如上面的initData
解析：将符号引用替换为直接引用，该阶段会把一些静态方法(符号引用，比如 main()方法，类名，方法名，修饰符等在JAVA虚拟机内部有个专业名词叫做符号)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)
初始化：对类的静态变量初始化为指定的值，执行静态代码块
- initData此时就会被初始化为666

扩展: 动态链接是在程序运行期间完成的将符号引用替换为直接引用。

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

2 懒加载（动态加载？）

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

简单演示一下下：

package study.wyy.jvm.classLoader;

public class TestDynamicLoad {

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

    public static void main(String[] args) {
        new A();
        System.out.println("*************load test************");
        // 这里没去new B，只是声明了而已
        B b = null;
    }
}

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 ************");
    }
}

分析代码特点：

没去new B，只是声明了而已
A是new了

输出结果

*************load TestDynamicLoad************
*************load A ************
*************initial A ************
*************load test************

总结

肯定会先加载TestDynamicLoad，就会去执行静态代码块，然后执行内部的main
这时候发现需要去加载A，就会执行A的静态代码块，然后执行A的构造方法
但是B只是声明了，没有去使用，不会去加载B，所有B的静态代码块也没有执行，更不会去执行构造了，除非使用了B（new B，调用B的静态方法等）

3 类加载器

3.1 类加载器简单介绍

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

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

简单演示：

public class TestJDKClassLoader {

    public static void main(String[] args) {
        System.out.println(String.class.getClassLoader());
        System.out.println(DESKeyFactory.class.getClassLoader());
        System.out.println(TestJDKClassLoader.class.getClassLoader());
        System.out.println();
    }
}

输出结果

null
sun.misc.Launcher$ExtClassLoader@7f31245a
sun.misc.Launcher$AppClassLoader@18b4aac2

为什么String的ClassLoader是null

String 是java的核心基础类，由引导类加载器加载，而引导类加载器是C++实现的，是C++的对象，在Java中是拿不到的。

3.1 类加载器的初始化

开头的图中已经说了：C++会调用java代码（getLauncher方法）创建jvm启动器sun.misc.Launcher#Launcher，再有这个类去加载其他的类加载器（除了引导类加载器）

部分源码

public class Launcher {
    private static URLStreamHandlerFactory factory = new Factory();
    // 可见在这个加载的时候就会new这个类的对象，
    private static Launcher launcher = new Launcher();
    private static String bootClassPath =
        System.getProperty("sun.boot.class.path");

    public static Launcher getLauncher() {
        return launcher;
    }
    // 构造方法的时候会给其赋值为APPClassLoader
    private ClassLoader loader;
    。。。

在看一下其构造方法

public Launcher() {
        // Create the extension class loader（创建扩展类加载器）
        ClassLoader extcl;
        try {
        	// 获取ExtClassLoader（扩展类加载器）
            extcl = ExtClassLoader.getExtClassLoader();
        } catch (IOException e) {
            throw new InternalError(
                "Could not create extension class loader", e);
        }

        // Now create the class loader to use to launch the application
        try {
        	// 其赋值为APPClassLoader
            loader = AppClassLoader.getAppClassLoader(extcl);
        } catch (IOException e) {
            throw new InternalError(
                "Could not create application class loader", e);
        }

        // Also set the context class loader for the primordial thread.
        Thread.currentThread().setContextClassLoader(loader);

        // Finally, install a security manager if requested
        String s = System.getProperty("java.security.manager");
        if (s != null) {
            // init FileSystem machinery before SecurityManager installation
            sun.nio.fs.DefaultFileSystemProvider.create();

            SecurityManager sm = null;
            if ("".equals(s) || "default".equals(s)) {
                sm = new java.lang.SecurityManager();
            } else {
                try {
                    sm = (SecurityManager)loader.loadClass(s).newInstance();
                } catch (IllegalAccessException e) {
                } catch (InstantiationException e) {
                } catch (ClassNotFoundException e) {
                } catch (ClassCastException e) {
                }
            }
            if (sm != null) {
                System.setSecurityManager(sm);
            } else {
                throw new InternalError(
                    "Could not create SecurityManager: " + s);
            }
        }
    }

ExtClassLoader.getExtClassLoader(); 显然ExtClassLoader是个单例的

/**
 * create an ExtClassLoader. The ExtClassLoader is created
 * within a context that limits which files it can read
 * 显然ExtClassLoader是个单例的
 */
public static ExtClassLoader getExtClassLoader() throws IOException
{
    if (instance == null) {
        synchronized(ExtClassLoader.class) {
            if (instance == null) {
                instance = createExtClassLoader();
            }
        }
    }
    return instance;
}

createExtClassLoader()

private static ExtClassLoader createExtClassLoader() throws IOException {
            try {
                // Prior implementations of this doPrivileged() block supplied
                // aa synthesized ACC via a call to the private method
                // ExtClassLoader.getContext().
				
                return AccessController.doPrivileged(
                    new PrivilegedExceptionAction<ExtClassLoader>() {
                        public ExtClassLoader run() throws IOException {
                        	// getExtDirs：获取 String s = System.getProperty("java.ext.dirs");
                        	// 这个路径下的class文件
                            final File[] dirs = getExtDirs();
                            int len = dirs.length;
                            for (int i = 0; i < len; i++) {
                                MetaIndex.registerDirectory(dirs[i]);
                            }
                            // 主要是这里构建了ExtClassLoader，上面是一些安全检查
                            return new ExtClassLoader(dirs);
                        }
                    });
            } catch (java.security.PrivilegedActionException e) {
                throw (IOException) e.getException();
            }
        }

new ExtClassLoader(dirs)

/*
  * Creates a new ExtClassLoader for the specified directories.
  */
 public ExtClassLoader(File[] dirs) throws IOException {
 	 // 调用父类UrLClassLoader的构造，加载我们磁盘上的文件，
 	 // 注意这里的第二个参数是null
     super(getExtURLs(dirs), null, factory);
     SharedSecrets.getJavaNetAccess().
         getURLClassPath(this).initLookupCache(this);
 }

loader = AppClassLoader.getAppClassLoader(extcl);

注意这里将刚刚的extClassLoader传了进来

public static ClassLoader getAppClassLoader(final ClassLoader extcl)
            throws IOException
        {	
        	// 获取环境变量，可以打印看一下，就是其一堆java的路径
            final String s = System.getProperty("java.class.path");
            final File[] path = (s == null) ? new File[0] : getClassPath(s);
			// 安全检查
            return AccessController.doPrivileged(
                new PrivilegedAction<AppClassLoader>() {
                    public AppClassLoader run() {
                    URL[] urls =
                        (s == null) ? new URL[0] : pathToURLs(path);
                    return new AppClassLoader(urls, extcl);
                }
            });
        }

new AppClassLoader(urls, extcl);

// ClassLoader parent: extClassLoader
AppClassLoader(URL[] urls, ClassLoader parent) {
	// // 调用父类UrLClassLoader的构造，加载我们磁盘上的文件，
	// 这里构造AppClassLoader第二个参数为extClassLoader，而上面构造extClassLoader传递的是null
    super(urls, parent, factory);
    ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);
    ucp.initLookupCache(this);
}

起初传递来的extClassLoader，干嘛了呢
**最终会在赋值给parent，也就是说AppClassLoader的parent属性是extClassLoader，
extClassLoader的parent属性是null，这里的null可以理解为引导类加载器（前面提到了引导类加载器是c++实现，在JAVA层面是拿不到的，所以上面获取string类的类加载器为null）
**

// java.lang.ClassLoader
private ClassLoader(Void unused, ClassLoader parent) {
        this.parent = parent;
        if (ParallelLoaders.isRegistered(this.getClass())) {
            parallelLockMap = new ConcurrentHashMap<>();
            package2certs = new ConcurrentHashMap<>();
            assertionLock = new Object();
        } else {
            // no finer-grained lock; lock on the classloader instance
            parallelLockMap = null;
            package2certs = new Hashtable<>();
            assertionLock = this;
        }
    }

回头看一下extClassLoader的parent属性是什么呢？

 public ExtClassLoader(File[] dirs) throws IOException {
 	 // 传了一个null，这里就可以理解为之前的引导类加载器，之前打印的是她就是个null
     super(getExtURLs(dirs), null, factory);
     SharedSecrets.getJavaNetAccess().
         getURLClassPath(this).initLookupCache(this);
 }

类加载器初始化过程：参见类运行加载全过程图可知其中会创建JVM启动器实例sun.misc.Launcher。 sun.misc.Launcher初始化使用了单例模式设计，保证一个JVM虚拟机内只有一个 sun.misc.Launcher实例。在Launcher构造方法内部，其创建了两个类加载器，分别是 sun.misc.Launcher.ExtClassLoader(扩展类加载器)和sun.misc.Launcher.AppClassLoader(应用类加载器)。 JVM默认使用Launcher的getClassLoader()方法返回的类加载器AppClassLoader的实例加载我们的应用程序。

简单验证一下


public static void main(String[] args) {
       
        ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
        ClassLoader extClassLoader = appClassLoader.getParent();
        ClassLoader bootstrapLoader = extClassLoader.getParent();
        System.out.println("system classLoader: " + appClassLoader);
        System.out.println("appClassLoader parent: " + extClassLoader);
        System.out.println("extClassLoader parent: " + bootstrapLoader);

    }

输出

system classLoader: sun.misc.Launcher$AppClassLoader@18b4aac2
appClassLoader parent: sun.misc.Launcher$ExtClassLoader@7f31245a
extClassLoader parent: null

wyaoyao93

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
01 类加载机制解析一

文章目录1 类加载器初始化和加载类的过程2 懒加载（动态加载？）3 类加载器3.1 类加载器简单介绍3.1 类加载器的初始化1 类加载器初始化和加载类的过程package study.wyy.jvm.classLoader;import study.wyy.jvm.model.User;public class Math { public static User user = new User(); public static final int initData = 666
复制链接

扫一扫