首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >类加载器ClassLoader

类加载器ClassLoader

作者头像
Liusy
发布2020-09-01 16:17:18
6640
发布2020-09-01 16:17:18
举报
文章被收录于专栏:Liusy01Liusy01

上篇文章说到,Class类可以通过一个类的全限定名去加载类,那么底层是如何去加载的呢?这就是我们今天要聊的类加载器ClassLoader,其可以通过一个类的全限定名来获取描述此类的二进制字节流,也即是将编译过后的Class文件加载到内存中。

需要注意的是,即使是同一个类,类加载器不一样,就必定不相等。

例如自定义了一个类加载器跟JVM默认加载器进行比对

/**
 *自定义类加载器
 */
class MyClassLoader extends ClassLoader {
    //类加载需要用到包名
    String packageName;

    public MyClassLoader(String packageName) throws ClassNotFoundException {
        this.packageName = packageName;
    }

    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
        String filename = name + ".class";
        name = packageName+"."+name.substring(name.lastIndexOf("/")+1);
        InputStream is = null;
        try {
            is = new FileInputStream(new File(filename));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        if (is == null) {
            return super.findClass(name);
        }
        try {
            byte[] bytes = new byte[is.available()];
            is.read(bytes);
            //根据class对应的二进制文件,调用defineClass
            return defineClass(name,bytes,0,bytes.length);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}
//参数是包名,类加载需要用到包名 
MyClassLoader myClassLoader = new MyClassLoader("com.liusy.lang");
//参数是java文件编译过后的全路径
Object obj = myClassLoader.loadClass("H:/Code/IDEACODE/java_source_code/out/production/java_source_code/com/liusy/lang/ClassSource");
System.out.println(obj);
System.out.println(obj instanceof ClassSource);

上述代码执行结果如下

Java的3种类加载器

1、Bootstrap ClassLoader,顶级加载器。

启动类加载器,加载JAVA_HOME/jre/lib下的核心类库,也是所有加载器的顶级父类,由c++所写。也可以用JVM参数-Xbootclasspath指定其加载的目录。

//查看其加载的jar包信息
Launcher.getBootstrapClassPath().getURLs()

2、Extension ClassLoader,扩展类加载器

负责加载JAVA_HOME/jre/lib/ext目录中的jar文件,是Application ClassLoader的父类。

//查看其加载的jar包信息
URL[] urLs = ((URLClassLoader) ClassLoader.getSystemClassLoader().getParent()).getURLs();

3、Application ClassLoader,应用程序类加载器

系统默认加载器,负责加载用户类所在路径的类信息。可以由ClassLoader.getSystemClassLoader()直接获取。

下图是获取系统类加载器以及获取其父类,可以看到,AppClassLoader的父类就是ExtClassLoader,而ExtClassLoader的父类是null,这是因为顶级加载器BootstrapClassLoader是用C++所写,java无法获取其信息。

JVM的双亲委派模型(保证父类加载器会先加载类)

工作流程:如果一个类加载器收到了类加载的请求,首先不会自己去尝试加载此类,而是把请求委派给父类加载器去完成,每一个层次的类加载器都是如此,因此所有的加载请求都会传送到顶层的启动类加载器中,只有当父加载器反馈无法完成此类的加载请求时,子加载器才会尝试自己去加载。

就是默认加载器不会一开始就去加载,一直往上抛,抛到最顶层,如果到最顶层了,此时又不能加载类,就会往下抛,直到加载完为止。

具体如下图

这个双亲委派特性体现在ClassLoader类的loadClass方法中

 //name:类的全限定名
 //resolve:是否链接到指定的类 
 protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{
    synchronized (getClassLoadingLock(name)) {
        //查看是否已被加载,如果是,则直接返回
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                //parent是父加载器,也就是一直往上抛
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    //没有父加载器,直接找顶级加载器
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
            }

            if (c == null) {
                long t1 = System.nanoTime();
                //父类加载器无法加载的时候
                //用自定义加载器去加载
                c = findClass(name);
            }
        }
        if (resolve) {
            //链接到指定的类
            resolveClass(c);
        }
        return c;
    }
}

上面的loadClass方法开头有一个加锁的代码,加锁的对象的getClassLoadingLock是这个方法返回的。

protected Object getClassLoadingLock(String className) {
    Object lock = this;
    //parallelLockMap是一个Map对象
    //parallelLockMap为空,则直接返回当前ClassLoader
    if (parallelLockMap != null) {
        Object newLock = new Object();
        //className作为key,如果存在,则直接返回旧值,如果不存在,
        //则将newLock作为value存入,此时lock就是newLock
        lock = parallelLockMap.putIfAbsent(className, newLock);
        if (lock == null) {
            lock = newLock;
        }
    }
    return lock;
}

而parallelLockMap 是什么东西呢?如下,是一个ConcurrentHashMap对象,文档显示是该类不为null的时候当前加载器就具有并行的功能。

private final ConcurrentHashMap<String, Object> parallelLockMap;
private ClassLoader(Void unused, ClassLoader parent) {
    this.parent = parent;
    //ParallelLoaders是静态内部类
    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;
    }
}
private static class ParallelLoaders {
        private ParallelLoaders() {}

        //拥有并行能力的set集合  
        private static final Set<Class<? extends ClassLoader>> loaderTypes =
            Collections.newSetFromMap(
                new WeakHashMap<Class<? extends ClassLoader>, Boolean>());
        static {
            synchronized (loaderTypes) { loaderTypes.add(ClassLoader.class); }
        }

        //往set集合上添加拥有并行能力的ClassLoader
        static boolean register(Class<? extends ClassLoader> c) {
            synchronized (loaderTypes) {
                if (loaderTypes.contains(c.getSuperclass())) {
                    loaderTypes.add(c);
                    return true;
                } else {
                    return false;
                }
            }
        }

        //判断某个ClassLoader是否拥有并行能力
        static boolean isRegistered(Class<? extends ClassLoader> c) {
            synchronized (loaderTypes) {
                return loaderTypes.contains(c);
            }
        }
    }

另外,自定义类加载器官方推荐是重写findClass()方法,这样可以确保是符合双亲委派模型的。

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2019-12-11,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Liusy01 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档