JVM -- 类加载器

jvm双亲委托

java双亲委托模型的好处
1.可以确保java核心库的类型安全，所有的java应用都至少会引用java.lang.object类，也就是说在运行期，java.lang.object 会被加载到java虚拟机中，如果这个加载过程是由java应用自己的类加载器加载所完成的。那么很可能就会在JVM中存在多个版本的java.lang.object类，而且这些类之间还是不兼容的，相互不可见的（正是命名空间在发挥作用）。
借助于双亲委托机制，java核心类库中的类加载工作都是由启动类，或者根类加载器来统一完成，从而确保了java应用使用的都是统一版本的核心类库。他们之间是相互兼容的。
2.可以确保Java核心类库所提供的类，不会被自定义的类所替代。
3.不同的类加载器可以为相同（binary name）名称的类创建额外的命名空间。相同名称的类可以并存在java虚拟机中，只需要用不同的类加载器来加载他们即可。不同类加载器所加载的类之间是不兼容的，这就相当于在java虚拟机内部创建了一个又一个相互隔离的java类空间，这类技术在很多框架中都得到了实际的应用。

上下文类加载器

当前类加载器 (Current Classloader)

每一个类都会使用自己的类加载器（即加载自身的类加载器）来去加载其他类（指的是所依赖的类）
如果classX引用了classY，那么classX的类加载器就回去加载classY（前提是classY尚未被加载）

线程上下文类加载器（Context Classloader）

线程上下文类加载器是从JDK1.2开始引入的，类Thread中的getContextClassloader()与setContextClassLoader(ClassLoader c1)
分别用来获取上下文的类加载器

如果没有通过setContextClassLoader(ClassLoader c1)进行设置的话，线程必须将继承其父线程的上下文类加载器.
Java应用运行时的初始线程的上下文类加载器是系统类加载器.在线程中运行的代码可以通过该类加载器来加载类与资源

线程上下文类加载器的重要性:
SPI(Service Provider Interface)
父Classloader可以使用当前线程Thread.currentThread.setContextLoader()所指定的classloader加载的类
这就改变了父ClassLoader不能使用ClassLoader或是其他没有直接父子关系的ClassLoader加载的类的情况，即改变了
双亲委托模型。

线程上下文类加载器就是当前线程的Current Classloader。
在双亲委托模型下，类加载是由上而下的，即下层的类加载器会委托上层进行加载。但是对于SPI来说，有些接口是Java核心库所提供的，
而Java核心库是由启动类加载器来加载的，而这些接口的的实现却来自于不同给jar包（厂商提供），Java的启动类加载器不会加载其他来源的jar包
这样传统的双亲委托模型就无法满足SPI的要求。而通过给当前线程设置上下文类加载器，就可以设置上下文类加载器来实现对于接口类的加载。

package com.jvm.classloader;

/**
 * @Author 晨边#CB
 * @Date:created in  2019/12/1 17:17
 * @Version V1.0
 **/
public class MyTest25 implements Runnable {
    private Thread thread;
    public MyTest25(){
        thread = new Thread(this);
        thread.start();
    }
    public void run() {
        ClassLoader classLoader = this.thread.getContextClassLoader();

        this.thread.setContextClassLoader(classLoader);

        System.out.println("class:"+classLoader.getClass());
        System.out.println("Parent:"+classLoader.getParent().getClass());

    }
    public static void main(String[] args) {
        new MyTest25();
    }
}

没有设置上下文加载器默认是系统类加载器

线程上下文加载的使用

线程上下文类加载器的一般使用模式(获取 - 使用 - 还原)

    ClassLoader classloader = Thread.currentThred().getContextClassLoader();

    try{
        Thread.currentThread().setContextClassLoader(targetTccl);
        myMethod():
    }finally{
        Thread.currentThread().setContextClassLoader(classLoder);
    }

    myMethod里面则调用了Thread.currentThread().getContextClassLoader().获取当前线程的上下文类加载器做
    的某些事情

    如果一个类由类加载器A加载，那么这个类的依赖类也是由相同的类加载的（如果该依赖类之前没有被加载过的话）

    ContextClassLoader的作用就是为了破坏Java的类加载委托机制

    当高层提供了统一的接口让底层实现，同时又要在高层加载（或实例化）底层的类时，就必须通过线程的上下文类加载器
    来帮助高层的ClassLoader找到并加载该类。

实例代码:

public class MyTest26 {
    public static void main(String[] args) {
        Thread.currentThread().setContextClassLoader(MyTest26.class.getClassLoader().getParent());//设置当前线程的classloader为扩展类加载器。导致下面的while循环不执行
        ServiceLoader<Driver> loader = ServiceLoader.load(Driver.class);

        Iterator<Driver> iterator = loader.iterator();

        while (iterator.hasNext()){
            Driver driver = iterator.next();

            System.out.println("driver:"+driver.getClass()+",loader:"+driver.getClass().getClassLoader());
        }
        System.out.println("当前线程上下文类加载器:"+Thread.currentThread().getContextClassLoader());
        System.out.println("Serviceloader的类加载器:"+ServiceLoader.class.getClassLoader());
    }

}