JVM类加载机制分析-51CTO.COM

一、类加载机制

什么是类加载机制？

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;
    }
    ...

}  1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

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);
    }
    ...
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

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());
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.

可见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);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

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);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

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;
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

调用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)
        
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.

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