JVM类加载机制分析

开发
Java虚拟机将编译后的.class文件加载到内存中,进行校验、转换、解析和初始化,到最终的使用,这就是类的加载机制。

一、类加载机制

什么是类加载机制?

Java虚拟机将编译后的.class文件加载到内存中,进行校验、转换、解析和初始化,到最终的使用,这就是类的加载机制。类的加载时机并未有明确的规定,但是类明确了类的初始化时机。

二、类加载机制的过程

类的加载机制大致分为五个过程:加载、验证、准备、解析、初始化。

1.加载

通过ClassLoader加载一个Class对象到内存中。具体过程:

  • 通过全限定名获取此类的二进制字节流(.class文件),至于二进制字节流在哪里获取并没有限制,可以从jar、apk、zip、数据库、网络、自己运行生成都可以。
  • 在内存中生成一个代表此类的java.lang.Class对象,并作为方法区这个类的访问入口。这个Class对象并没有规定放在Java堆中,有些虚拟机将它放在方法区中。

2.验证

验证加载后的类是否符合.Class文件结构,类数据是否符合虚拟机的要求,确保不会危害虚拟机的安全。具体过程如下:

  • 文件格式验证:验证二机制字节流是否符合.class的文件格式,并且验证该.class文件是否在虚拟机的处理范围内,文件格式验证合格后才将二进制的数据存放在内存的方法区中。
  • 元数据验证:主要是对该类的元数据信息进行语义检查,保证不存在不符合 Java 语义规范的元数据信息。
  • 字节码验证:主要对类的方法体进行验证,确保类的方法不会做出危害虚拟机的行为
  • 符号引用验证:对类本身饮用其他类型的验证,包括对全限定名是否能找到对应的类,是否能找到对应的类的方法和字段,访问性是否合适。

3.准备

  • 对于类变量(static修饰)为其分配内存,并赋值初始值(如0,false)。
  • 对于常量(final修饰)为其赋值设置的数值。

4.解析

将类符号引用转换成直接引用。

5.初始化

给类变量(static)赋值,并执行static{}方法。这里的触发执行的方法是类构造器中。

  • 类构造器是编译器自己生成的,它会按类的顺序的收集类变量和静态代码块,如果一个类中没有类变量也没有静态代码块将没有类构造器。它和实例构造器是不同。
  • 父类的构造器将优先于子类的构造器执行。子接口的构造器不需要调用父类的类构造器。
  • 静态代码块可以访问出现在它前面的静态变量,但不能访问后面的静态变量,只可以赋值。

类初始化的时机:

  • new一个对象的时候;获取和设置static的变量和方法的时候;
  • 使用 java.lang.reflect 包对方法进行反射调用的时候。
  • 当一个类的父类没被初始化时,会优先初始化父类。
  • 当虚拟机启动时,需要指定一个要执行的主类时候。
  • 当使用 JDK 1.7 的动态语言支持时,如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getStatic、REF_putStatic、REF_invodeStatic 的方法句柄,并且这个方法句柄所对应的类没有进行过初始化,则需要先触发其初始化。

三、类加载器ClassLoader

这里的ClassLoader是安卓的类加载器,不是Java的加载器,这是有区分的,比如Java的类加载器加载的是jar里面的.class文件的集合,而安卓则是将.class文件的集合全部写入到一个dex文件中,删除一些重复的代码,以此来提高性能。

1.ClassLoader的类型

Android的类加载器类型也可以分为两种:

  • 系统类加载器
  • 自定义类加载器

无论哪种加载器,它们都要继承ClassLoader这个抽象父类。其中系统类加载器主要有:BootClassLoader、PathClassLoader、DexClassLoader

(1) BootClassLoader

class BootClassLoader extends ClassLoader {

    private static BootClassLoader instance;

    @FindBugsSuppressWarnings("DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED")
    public static synchronized BootClassLoader getInstance() {
        if (instance == null) {
            instance = new BootClassLoader();
        }

        return instance;
    }
    ...

}  

BootClassLoader继承于ClassLoader,它是一个没有父加载器的加载器,它在Zygote进程启动的时候,BootClassLoader加载器将会被创建,用它加载一些预加载类,方便以后fork进程时复用资源。同时它也是ClassLoader的内部类。

(2) PathClassLoader

public class PathClassLoader extends BaseDexClassLoader {

    /**
     * @param dexPath : Dex相关文件的路径
     * @param parent  : 父加载器
     */
    public PathClassLoader(String dexPath, ClassLoader parent) {
        super(dexPath, null, null, parent);
    }

    /**
     * @param dexPath: Dex相关文件的路径
     * @param librarySearchPath:包含C/C++库的路径集合
     * @param parent : 父加载器
     */
    public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
    ...
}

PathClassLoader继承BseDexClassLoader,同时BaseDexClassLoader继承ClassLoader。 PathClassLoader的创建在system_server进程中,PathClassLoader类加载器通常加载已经安装的apk的dex文件。 PathClassLoader类加载器默认的解压的dex文件的存储路径是:/data/dalvik_cache路径中。 如下是创建的时机:

public class ZygoteInit {

    // 创建完system_server进程后,会执行此方法
    private static Runnable handleSystemServerProcess(ZygoteArguments parsedArgs) {
        if (systemServerClasspath != null) {
            //...
        } else {
            ClassLoader cl = null;
            // 创建PathClassLoader加载器
            if (systemServerClasspath != null) {
                cl = createPathClassLoader(systemServerClasspath, parsedArgs.mTargetSdkVersion);
            }
        }
    }

    static ClassLoader createPathClassLoader(String classPath, int targetSdkVersion) {
        String libraryPath = System.getProperty("java.library.path");

        // 父加载器是BootClassLoader
        ClassLoader parent = ClassLoader.getSystemClassLoader().getParent();

        // 创建工厂模式创建PathClassLoader
        return ClassLoaderFactory.createClassLoader(classPath, libraryPath, libraryPath,
                parent, targetSdkVersion, true /* isNamespaceShared */, null /* classLoaderName */);
    }

}


public abstract class ClassLoader {

    public static ClassLoader getSystemClassLoader() {
        return SystemClassLoader.loader;
    }

    static private class SystemClassLoader {
        public static ClassLoader loader = ClassLoader.createSystemClassLoader();
    }

    private static ClassLoader createSystemClassLoader() {
        String classPath = System.getProperty("java.class.path", ".");
        String librarySearchPath = System.getProperty("java.library.path", "");
        // 父加载器是BootClassLoader
        return new PathClassLoader(classPath, librarySearchPath, BootClassLoader.getInstance());
    }
}

可见PathClassLoader的父加载器是BootClassLoader。

(3) DexClassLoader

public class DexClassLoader extends BaseDexClassLoader {

    /**
     *
     * @param dexPath : Dex相关文件的路径
     * @param optimizedDirectory: 解压的dex的存储路径
     * @param librarySearchPath:包含C/C++库的路径集合
     * @param parent : 父加载器
     */
    public DexClassLoader(String dexPath, String optimizedDirectory, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
}

DexClassLoader也是继承BaseDexClassLoader,相比PathClassLoader则是可以定义解压dex的存储路径。

除了BootClassLoader、PathClassLoader、DexClassLoader这三个类加载器外还有,InMemoryDexClassLoader:用于加载内存的dex;SecureClassLoader:权限检查的ClassLoader;URLClassLoader:URL的ClassLoade。

2.ClassLoader的加载过程

Android中所有的类加载器都继承于ClassLoader抽象类,这个类的loadClass()方法同样实现了双亲委托机制。

(1) 双亲委托机制

public abstract class ClassLoader {

   /**
     * 双亲委托机制
     */
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        // 1. 先检查class是否已经加载过
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            // 没有加载过
            try {
                if (parent != null) {
                    // 先给父ClassLoader加载Class
                    c = parent.loadClass(name, false);
                } else {
                    // 调用BootClassLoader加载Class
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }


            if (c == null) {
                // 父的ClassLoader都没有加载class,则调用findClass()给此ClassLoader加载
                c = findClass(name);
            }
        }
        return c;
    }


    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
}

ClassLoader的loadClass()方法定义了加载器加载类的过程:

  • 如果class文件已经加载过,则从缓存中找。否则给递归给父加载器的loadClass()方法查找class文件
  • 如果父加载器没找到,则调用自己的findClass(name)方法开始找class文件。 这种设计避免了一些核心类的加载被用户自定义复写,导致功能不同。

那这个findClass()方法在ClassLoader中是一个空实现,它让给你子类去实现这个查找的过程。那这里以BaseDexClassLoader为例,看findClass()是如何查找class文件的:

public class BaseDexClassLoader extends ClassLoader {

    private final DexPathList pathList;

    public BaseDexClassLoader(String dexPath,
                              String librarySearchPath, ClassLoader parent, ClassLoader[] sharedLibraryLoaders,
                              boolean isTrusted) {
        super(parent);
        this.sharedLibraryLoaders = sharedLibraryLoaders == null
                ? null
                : Arrays.copyOf(sharedLibraryLoaders, sharedLibraryLoaders.length);
        this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);

        reportClassLoaderChain();
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //  调用DexPathList.findClass方法查找class
        Class c = pathList.findClass(name, suppressedExceptions);
        if (c == null) {
            ClassNotFoundException cnfe = new ClassNotFoundException(
                    "Didn't find class \"" + name + "\" on path: " + pathList);
            for (Throwable t : suppressedExceptions) {
                cnfe.addSuppressed(t);
            }
            throw cnfe;
        }
        return c;
    }
}

调用DexPathList.findClass()方法去查找class文件:

public final class DexPathList {
    private Element[] dexElements;

    DexPathList(ClassLoader definingContext, String dexPath,
                String librarySearchPath, File optimizedDirectory, boolean isTrusted) {
         this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
                suppressedExceptions, definingContext, isTrusted);
    }

    public Class<?> findClass(String name, List<Throwable> suppressed) {
        // 遍历Element数组去查询
        for (Element element : dexElements) {
            Class<?> clazz = element.findClass(name, definingContext, suppressed);
            if (clazz != null) {
                return clazz;
            }
        }

        if (dexElementsSuppressedExceptions != null) {
            suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
        }
        return null;
    }

}


    /*package*/ static class Element {
        @UnsupportedAppUsage
        private final File path;
    
        private final Boolean pathIsDirectory;

        @UnsupportedAppUsage
        private final DexFile dexFile;

        private ClassPathURLStreamHandler urlHandler;
        private boolean initialized;

        @UnsupportedAppUsage
        public Element(DexFile dexFile, File dexZipPath) {
            if (dexFile == null && dexZipPath == null) {
                throw new NullPointerException("Either dexFile or path must be non-null");
            }
            this.dexFile = dexFile;
            this.path = dexZipPath;
            this.pathIsDirectory = (path == null) ? null : path.isDirectory();
        }

        public Class<?> findClass(String name, ClassLoader definingContext,
                                  List<Throwable> suppressed) {
             //  调用DexFile.loadClassBinaryName()方法去查找
            return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed)
                    : null;
        }
}

public final class DexFile {

    public Class loadClassBinaryName(String name, ClassLoader loader, List<Throwable> suppressed) {
        return defineClass(name, loader, mCookie, this, suppressed);
    }

    private static Class defineClass(String name, ClassLoader loader, Object cookie,
                                     DexFile dexFile, List<Throwable> suppressed) {

        Class result = null;
        try {
            result = defineClassNative(name, loader, cookie, dexFile);
        }
        ...
        return result;
    }

    private static native Class defineClassNative(String name, ClassLoader loader, Object cookie, DexFile dexFile)
        
}

DexPathList有一个Element[]数组,每个Element有dex文件路径,通过遍历Element[]数组,调用Element. loadClassBinaryName()方法去查找是否对应的class文件,最后调用defineClassNative()native方法去查找。

责任编辑:赵宁宁 来源: 沐雨花飞蝶
相关推荐

2023-08-02 08:38:27

JVM加载机制

2017-09-20 08:07:32

java加载机制

2021-04-29 11:18:14

JVM加载机制

2017-03-08 10:30:43

JVMJava加载机制

2024-03-12 07:44:53

JVM双亲委托机制类加载器

2022-10-08 08:34:34

JVM加载机制代码

2021-09-24 08:10:40

Java 语言 Java 基础

2020-10-26 11:20:04

jvm类加载Java

2020-10-30 08:35:23

Java Virtua

2020-05-20 22:13:26

JVM加载机制虚拟机

2019-12-30 11:25:06

Jvm运行java

2021-06-16 00:57:16

JVM加载机制

2021-07-05 06:51:43

Java机制类加载器

2024-03-08 08:26:25

类的加载Class文件Java

2021-02-28 11:58:33

JVM机制语言

2021-05-25 09:56:42

Jvm类加载机制Java

2021-01-06 09:01:05

javaclass

2024-09-06 09:37:45

WebApp类加载器Web 应用

2024-09-04 09:47:21

2024-04-09 08:41:41

JVM类加载Java
点赞
收藏

51CTO技术栈公众号