学习记录392@深入理解JVM类加载机制

感谢某视频,这里就将自己学习后做的笔记截图上来了,因为用md写的好看一点,最后附上了文档内容。
学习记录392@深入理解JVM类加载机制_第1张图片
学习记录392@深入理解JVM类加载机制_第2张图片
学习记录392@深入理解JVM类加载机制_第3张图片
接上
学习记录392@深入理解JVM类加载机制_第4张图片
接上
学习记录392@深入理解JVM类加载机制_第5张图片
学习记录392@深入理解JVM类加载机制_第6张图片
学习记录392@深入理解JVM类加载机制_第7张图片
接上
学习记录392@深入理解JVM类加载机制_第8张图片
学习记录392@深入理解JVM类加载机制_第9张图片
学习记录392@深入理解JVM类加载机制_第10张图片
接上
学习记录392@深入理解JVM类加载机制_第11张图片
接上
学习记录392@深入理解JVM类加载机制_第12张图片
学习记录392@深入理解JVM类加载机制_第13张图片
接上
学习记录392@深入理解JVM类加载机制_第14张图片
接上
学习记录392@深入理解JVM类加载机制_第15张图片
学习记录392@深入理解JVM类加载机制_第16张图片

从JDK源码深入理解JVM的类加载机制

类加载过程

  • 加载
    • 将class文件读取到JVM内存中,采用的懒加载模式,只有使用到类时才加载,比如调用main方法,new对象时,加载阶段会在内存中生成Class对象,作为方法区这个类的各种数据访问入口。
  • 验证
    • 验证字节码文件的正确性。
  • 准备
    • 给类的静态变量分配内存,并赋予初始值。
  • 解析
    • 符号引用替换为直接引用,这就是静态链接过程,如果时运行期间将符号引用转化为直接引用,则是动态链接。
  • 初始化
  • 对类的静态变量初始化为指定的值,并执行静态代码块,这就是为什么静态代码块比构造方法先执行的原因。

类加载器

  • 引导类加载器
    • 在JVM启动时自动加载的,是用C++写的程序,加载JRE-LIB文件夹下面的一些支撑Java程序运行的jar包,比如rt.jar;于此同时引导类加载器会自动创建launcher类,用于加载扩展类加载器和应用程序类加载器,且分清楚两者的上下级关系,上级是扩展类加载器,下级是应用程序类加载器。
  • 扩展类加载器
    • 加载JRE-LIB-EXT文件夹下面的一些扩展jar包,如sunjce_provider.jar。
  • 应用程序类加载器
    • 加载在类路径下的自己写的类
  • 自定义类加载器

双亲委派机制

什么是双亲委派机制

当加载某个类时,先交给应用程序类加载器,看是否已经加载过,如果没有加载过,交给扩展类加载器,看是否已经加载过,如果没有加载过,交给引导类加载器,看是否已经加载过,如果没有加载过,就尝试加载,如果加载失败,交给扩展类加载器,尝试加载,如果加载失败,交给应用程序类加载器,尝试加载,如果失败就失败了,如果成功就成功了。

核心源码
//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 {
                    //没有加载过,交给上级类加载器去加载
                    //parent表明某个加载器有个属性是parent,不要理解为这几个类加载器是继承关系
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        //没有上级类加载器,扩展类加载器的parent就为null了,就直接交给引导类加载器处理,本地方法,无法查看
                        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();
                    //自己尝试加载,调用UrlClassLoader类中的findClass方法
                    //这是个空实现,扩展类加载器时,因为继承的是UrlClassloader的这个方法
                    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;
        }
    }
//应该被实现类重写这个方法,然后执行,这里也就是要执行UrlClassLoader的findClass,自定义类加载器的化就是重写这个方法即可!
//为什么是执行rlClassLoade的findClass呢?因为扩展类加载器没有findClass方法,而扩展类加载器是继承UrlClassLoader的,因此就是执行UrlClassLoader的findClass方法了
/**
     * Finds the class with the specified binary name.
     * This method should be overridden by class loader implementations that
     * follow the delegation model for loading classes, and will be invoked by
     * the {@link #loadClass loadClass} method after checking the
     * parent class loader for the requested class.  The default implementation
     * throws a ClassNotFoundException.
     *
     * @param  name
     *         The binary name of the class
     *
     * @return  The resulting Class object
     *
     * @throws  ClassNotFoundException
     *          If the class could not be found
     *
     * @since  1.2
     */
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
//URLClassLoader类中
//就是找那个类,然后加载进JVM内存中
//就是在执行加载、验证、准备、解析、初始化的过程
protected Class<?> findClass(final String name)
        throws ClassNotFoundException
    {
        final Class<?> result;
        try {
            result = AccessController.doPrivileged(
                new PrivilegedExceptionAction<Class<?>>() {
                    public Class<?> run() throws ClassNotFoundException {
                        String path = name.replace('.', '/').concat(".class");
                        Resource res = ucp.getResource(path, false);
                        if (res != null) {
                            try {
                                //加载进JVM内存中
                                return defineClass(name, res);
                            } catch (IOException e) {
                                throw new ClassNotFoundException(name, e);
                            }
                        } else {
                            return null;
                        }
                    }
                }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }
为什么设计双亲委派机制
  • 沙箱安全机制
    • 假如自定义一个类和JDK的类的包名和类名完全一致,但是内部的方法不一样,这个时候运行程序就会报错,因为上级的类加载器会加载到这个类,但是没有自定义的方法。比如自定义一个java.lang.String,但是内部有一个main方法,并且运行,就会报错,因为这个类会被引导类加载器加载,但本身String类时没有main方法的。
    • 好处:防止恶意串改JDK最基本的类,要不然你就可以自己写一个类,覆盖原始的类,别人运行就会报错的。
  • 避免类的重复加载
    • 很好理解,就是上级加载了,下级就不会加载了。
  • 为什么要向上委托而不是向下委托
    • 比较好的解释是,因为大部分程序的类都是自定义的,就可以做到大部分类由应用程序类加载器加载,要不然每次都先从上级开始,委派给下级,这样会造成很大的浪费。
  • 为什么要一层层委托,然后从上层开始如果加载失败才交给下层加载,而不是下层开始能加载就加载,不能加载就再给上层加载
    • 上面已经确认向上委托的好处,如果不向上委托,就是当需要加载某个类是,下级能加载,就加载,那不就破坏杀向安全机制了么,比如自定义一个java.lang.String,应用程序类加载器能加载,就加载了,就可以篡改JDK以下原始的类了,造成很大的风险。
自定义类加载器
自定义类加载器代码实现
package cn.cdqf.mydmsjportal.test;


import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;

public class MyClassLoaderTest{

    static class MyClassLoader extends ClassLoader{
        private String classPath;
        public MyClassLoader(String classPath){
            this.classPath=classPath;
        }

        private byte[] loadByte(String name) throws IOException {
            name=name.replaceAll("\\.","/");
            FileInputStream fileInputStream = new FileInputStream(classPath + "/" + name+".class");
            int len= fileInputStream.available();//获取文件大小
            byte[] bytes = new byte[len];
            fileInputStream.read(bytes);
            fileInputStream.close();
            return bytes;
        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] bytes = loadByte(name);
                return defineClass(name,bytes,0,bytes.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }
    }


    public static void main(String[] args) {
        MyClassLoader myClassLoader = new MyClassLoader("D:\\qianfeng\\JavaEE2007\\self-study\\");
        try {
            //不要写成findClass!!!
            Class<?> aClass = myClassLoader.loadClass("cn.cdqf.mydmsjportal.test.Test");
            Object newInstance = aClass.newInstance();
            Method method = aClass.getMethod("test");
            method.invoke(newInstance,null);
            //打印使用的类加载器
            System.out.println(aClass.getClassLoader().getClass().getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
测试

建一个文件夹,放入Test.class,然后运行程序,得到的结果如下:

学习记录392@深入理解JVM类加载机制_第17张图片

测试自定义类加载器
sun.misc.Launcher$AppClassLoader

为什么是AppClassLoader

这就是因为双亲委派机制,因为程序中的类路径下Test.class存在,就由父级加载器加载了,为什么自定义类加载器的父级类加载器是AppClassLoader?一方面是为了遵循双亲委派机制,另一方面从源码的角度来看:

    //传入的就是系统类加载器,而系统类加载器默认的就是应用程序类加载器

    protected ClassLoader() {
        this(checkCreateClassLoader(), getSystemClassLoader());
    }
    
    
   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;
        }
    }


//获取系统类加载器,注意initSystemClassLoader();,初始化系统类加载器
@CallerSensitive
    public static ClassLoader getSystemClassLoader() {
        initSystemClassLoader();
        if (scl == null) {
            return null;
        }
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkClassLoaderPermission(scl, Reflection.getCallerClass());
        }
        return scl;
    }


//初始化系统类加载器,注意scl = l.getClassLoader();
private static synchronized void initSystemClassLoader() {
        if (!sclSet) {
            if (scl != null)
                throw new IllegalStateException("recursive invocation");
            sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
            if (l != null) {
                Throwable oops = null;
                scl = l.getClassLoader();
                try {
                    scl = AccessController.doPrivileged(
                        new SystemClassLoaderAction(scl));
                } catch (PrivilegedActionException pae) {
                    oops = pae.getCause();
                    if (oops instanceof InvocationTargetException) {
                        oops = oops.getCause();
                    }
                }
                if (oops != null) {
                    if (oops instanceof Error) {
                        throw (Error) oops;
                    } else {
                        // wrap the exception
                        throw new Error(oops);
                    }
                }
            }
            sclSet = true;
        }
    }

//获得类加载器
public ClassLoader getClassLoader() {
        return this.loader;
    }

//初始化会调用默认无参构造方法,loader赋值为AppClassLoader,搞定!
public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }

        try {
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }

        Thread.currentThread().setContextClassLoader(this.loader);
        String var2 = System.getProperty("java.security.manager");
        if (var2 != null) {
            SecurityManager var3 = null;
            if (!"".equals(var2) && !"default".equals(var2)) {
                try {
                    var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
                } catch (IllegalAccessException var5) {
                } catch (InstantiationException var6) {
                } catch (ClassNotFoundException var7) {
                } catch (ClassCastException var8) {
                }
            } else {
                var3 = new SecurityManager();
            }

            if (var3 == null) {
                throw new InternalError("Could not create SecurityManager: " + var2);
            }

            System.setSecurityManager(var3);
        }
    }
打破双亲委派机制

以上不让父级类加载器加载Test的方法有两个,一个是在类路径下删除,另外一个方法就是打破双亲委派机制,双亲委派机制的核心在loadClass方法中,因此重写即可!

package cn.cdqf.mydmsjportal.test;


import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;

public class MyClassLoaderTest{

    static class MyClassLoader extends ClassLoader{
        private String classPath;
        public MyClassLoader(String classPath){
            this.classPath=classPath;
        }

        private byte[] loadByte(String name) throws IOException {
            name=name.replaceAll("\\.","/");
            FileInputStream fileInputStream = new FileInputStream(classPath + "/" + name+".class");
            int len= fileInputStream.available();//获取文件大小
            byte[] bytes = new byte[len];
            fileInputStream.read(bytes);
            fileInputStream.close();
            return bytes;
        }

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] bytes = loadByte(name);
                return defineClass(name,bytes,0,bytes.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        @Override
        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();
                    //注意

                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
//                   如果不是是要自己加载的,就让父级去加载
//                    注意不能全部让自定义类加载器去加载,因为有些父级比如object是需要提前加载的
//                    这些必须用父级加载器去加载
//                    否则会报错:java.io.FileNotFoundException: D:\qianfeng\JavaEE2007\self-study\java\lang\Object.class (系统找不到指定的路径。)
                    if (!name.startsWith("cn.cdqf.mydmsjportal.test")){
                        c=this.getParent().loadClass(name);
                    }else {
                        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;
            }
        }
    }


    public static void main(String[] args) {
        MyClassLoader myClassLoader = new MyClassLoader("D:\\qianfeng\\JavaEE2007\\self-study\\");
        try {
            //不要写成findClass!!!
            Class<?> aClass = myClassLoader.loadClass("cn.cdqf.mydmsjportal.test.Test");
            Object newInstance = aClass.newInstance();
            Method method = aClass.getMethod("test");
            method.invoke(newInstance,null);
            //打印使用的类加载器
            System.out.println(aClass.getClassLoader().getClass().getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
测试

这样就是直接使用自定义类加载器啦

测试自定义类加载器
cn.cdqf.mydmsjportal.test.MyClassLoaderTest$MyClassLoader

你可能感兴趣的:(学习记录392@深入理解JVM类加载机制)