1. 类加载机制
在之前的文章万字长文把[JVM]从头到尾讲一遍
中详细讲了JVM虚拟机的内存结构和垃圾回收算法，如下图概述了JVM整个的运行机制，今天来讲讲最上面的类加载机制部分。
JVM
-
什么是类加载机制？
Java虚拟机将编译后的.class文件加载到内存中，进行校验、转换、解析和初始化，到最终的使用，这就是类的加载机制。类的加载时机并未有明确的规定，但是类明确了类的初始化时机。
2. 类加载机制的过程
类的加载机制大致分为五个过程：加载、验证、准备、解析、初始化。下面将分析每个过程中做了什么事。
2.1 加载
通过ClassLoader加载一个Class对象到内存中。具体过程：
- 通过全限定名获取此类的二进制字节流(.class文件)，至于二进制字节流在哪里获取并没有限制，可以从jar、apk、zip、数据库、网络、自己运行生成都可以。
- 在内存中生成一个代表此类的java.lang.Class对象，并作为方法区这个类的访问入口。这个Class对象并没有规定放在Java堆中，有些虚拟机将它放在方法区中。
2.2 验证
验证加载后的类是否符合.Class文件结构，类数据是否符合虚拟机的要求，确保不会危害虚拟机的安全。具体过程如下：
- 文件格式验证：验证二机制字节流是否符合.class的文件格式，并且验证该.class文件是否在虚拟机的处理范围内，文件格式验证合格后才将二进制的数据存放在内存的方法区中。
- 元数据验证：主要是对该类的元数据信息进行语义检查，保证不存在不符合 Java 语义规范的元数据信息。
- 字节码验证：主要对类的方法体进行验证，确保类的方法不会做出危害虚拟机的行为
- 符号引用验证：对类本身饮用其他类型的验证，包括对全限定名是否能找到对应的类，是否能找到对应的类的方法和字段，访问性是否合适。
2.3 准备
- 对于类变量(static修饰)为其分配内存，并赋值初始值(如0，false)。
- 对于常量(final修饰)为其赋值设置的数值。
2.4 解析
将类符号引用转换成直接引用。
2.5 初始化
给类变量(static)赋值，并执行static{}方法。这里的触发执行的方法是类构造器<clinit>中。
- 类构造器<clinit>是编译器自己生成的，它会按类的顺序的收集类变量和静态代码块，如果一个类中没有类变量也没有静态代码块将没有类构造器。它和实例构造器<init>是不同。
- 父类的构造器将优先于子类的构造器执行。子接口的构造器不需要调用父类的类构造器。
- 静态代码块可以访问出现在它前面的静态变量，但不能访问后面的静态变量，只可以赋值。
2.5.1类初始化的时机
- new一个对象的时候；获取和设置static的变量和方法的时候；
- 使用 java.lang.reflect 包对方法进行反射调用的时候。
- 当一个类的父类没被初始化时，会优先初始化父类。
- 当虚拟机启动时，需要指定一个要执行的主类时候。
- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getStatic、REF_putStatic、REF_invodeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。
3. 类加载器ClassLoader
这里讲解的ClassLoader是安卓的类加载器，不是Java的加载器，这是有区分的,比如Java的类加载器加载的是Jar里面的.class文件的集合，而安卓则是将.class文件的集合全部写入到一个dex文件中，删除一些重复的代码，以此来提高性能。
3.1 ClassLoader的类型
Android的类加载器类型也可以分为两种：
- 系统类加载器
- 自定义类加载器
无论哪种加载器，它们都要继承ClassLoader这个抽象父类。其中系统类加载器主要有：BootClassLoader、PathClassLoader、DexClassLoader
3.1.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的内部类。
3.1.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.1.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。
Android ClassLoader关系
3.2 ClassLoader的加载过程
Android中所有的类加载器都继承于ClassLoader抽象类，这个类的loadClass()方法同样实现了双亲委托机制。
3.2.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方法去查找。
