ClassLoader类加载

一、jvm类加载

1.类加载器作用

　　　　①将.class文件加载到jvm ②将class文件统一编码成jvm要求格式  

2. 类加载过程

　　　            　

1）加载

　　将字节码（可能是.class文件、jar包或者网络等）转化为二进制字节流加载到内存中

 2）验证

　　jvm对转化为二进制字节流进行校验，只有符合jvm字节码规范的才能被jvm正确执行，主要检查:

　　　　　　a:确保方法调用参数类型和个数是否正确

　　　　　　b:检查变量是否被赋予恰当类型值

　　　　　　c:确保变量在使用前被正确初始化

3）准备

　　jvm对类变量（静态变量）分配内存并初始化

　　例子：　　　

public String chenmo = "沉默";
public static String wanger = "王二";
public static final String cmower = "沉默王二";

 

 　　chenmo准备阶段不会初始化                               //chenmo不是类变量        

　　 wanger准备阶段的初始值不是"王二"而是null      //wanger是类变量

　　 cmower准备阶段的值“沉默王二”                         //cmowner是static final修饰的变量，称之为常量，常量一旦被赋值就不会改变，所以cmowner在准备阶段初始值是“沉默王二”

 

4）解析

　　将常量池中符号引用转化为直接引用

　　符号引用：编译时java类不知道引用类实际地址，因此只能通过符号引用来代替。比如com.Wanger类引用com.Chenmo类，编译时Wanger类不知道Chenmo类的实际内存地址，只能使用符号com.Chenmo（名字引用）

　　直接引用：通过对符号引用进行解析，找到引用类实际内存地址（地址引用）

 

5）初始化 

　　准备阶段为类变量赋默认初始值，初始化阶段为类变量赋值为代码期望赋的值

public static String wanger = "王二";

 

 wanger初始化阶段的初始值是"王二"而不是null      

 

 

 

2、类加载器

　　

初始化时机：

　　　　　　a)创建类的实例

　　　　　　b)对类进行反射调用，如果该类没有没初始化则需要先触发其初始化

　　　　　　c)初始化一个类的时候，如果其父类没有初始化，需要先对其父类进行初始化

　　　　　　d)当虚拟机启动时，用户需要一个执行主类，这个主类会初始化

　　类实例化VS类初始化

　　　　　　类实例化是创建一个类的实例对象

　　　　　　类初始化是对类的成员变量（static修饰的变量）赋初始值的过程

3.类加载机制

　                　

　　　　启动类（bootstrap classLoader）：jre/bin目录下jar  对应开发项目中JRE System

　　　    扩展类（extension classLoader）：jre/bin/ext目录下jar  对应开发项目中JRE System

　　　　应用类（application classLoader）：编码者自己编码目录，对应开发项目中

 

4、ClassLoader类加载原理（双亲委派）

　　除了启动类加载器（bootstrap classloader）都有父类加载器。当一个classloader实例需要加载某个类时，会把任务委托给父类加载器，如果父类加载器加载失败会委托给启动类加载器，如果都失败才会在该类加载器中进行类加载。最后如果都没有加载到这个类，则抛出classnotfoundexception

 

5、双亲委派好处

　　①避免重复加载，父类加载后，classloader不需要再加载一次

　　②安全因素，双亲委托的方式，就可以避免自己随机定义的String来代替java核心api，因为String已经在启动时就被引导类加载器（Bootstrcp ClassLoader）加载，所以用户自定义的ClassLoader永远也无法加载一个自己写的String

 

6、classLoader代码

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();
                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();
                    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;
        }
    }

    protected final Class<?> findLoadedClass(String name) {
        if (!checkName(name))
            return null;
        return findLoadedClass0(name);
    }

　　上边代码递归寻找父类加载器后else原因是BootStrapClassLoader是C写的，扩展类无法找到其父类加载器，所以if条件最终只会找到扩展类加载器

　　　代码流程：　　

 　　　　　　　　　　

 

　　　　代码注意点：①synchronized (getClassLoadingLock(name))  

　　　　　　　　　　分析getClassLoadingLock():

　　　　　　　　　　　　a: getclassLoadingLock()方法：　　　　　　　　　　　　　

                            

protected Object getClassLoadingLock(String className) {
        Object lock = this;
        if (parallelLockMap != null) {
            Object newLock = new Object();
            lock = parallelLockMap.putIfAbsent(className, newLock);
            if (lock == null) {
                lock = newLock;
            }
        }
        return lock;
    }

　　　　　　　　　　　　b: parallelLockMap定义：　　　　　　　　　　　

　　　　　　　　　　　　　　　　private final ConcurrentHashMap<String, Object> parallelLockMap;
　　　　　　　　parallelLockMap初始化在classLoader中：　　　　　　　　   

                            

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

　　　　　　　　　　　　c: 根据ParallelLoaders的Registered状态的不同来给parallelLockMap 赋值

　　　　　　　② findLoadedClass(name) 首先从jvm内存中查找该类，如果不存在再去加载

　　　　　　　③ parent.loadClass(name, false);多次递归调用该方法，用以发现根节点的父类加载器

 

二、Tomcat类加载机制

                                       

　　启动类、扩展类、应用程序类加载器是jdk自带的类加载器

　　Tomcat类加载包括两种类型的类库：Tomcat容器加载依赖类库和web程序应用类库

common类加载器：tomcat容器和web应用程序都复用的类

catalina类加载器：tomcat容器加载所依赖的类，对web应用程序不可见

shared类加载器：所有web应用程序加载所依赖类，对tomcat容器加载所依赖的类不可见

webApp类加载器：负责加载具体的某个web应用程序所使用的的类，对其他web应用程序不可见，对tomcat容器加载类不可见

jsp类加载器：每个jsp页面都有一个类加载器，不同jsp页面有不同的类加载器，方便实现jsp页面的热插拔

 

参考：https://www.jianshu.com/p/51b2c50c58eb