【Android食用指南-01】Android虚拟机&类加载机制

长发却不及腰

媒介

正在上一篇文章中【JVM进门食用指北-03】JVM渣滓采取器和机能调劣[1]，对渣滓采取器和JVM机能调劣停止了叙说,并对JVM中CMS渣滓采取器停止了重面论述。经由过程之前正在JVM中的展垫，本文我们回到Android中，本文我们次要对 Android假造机战类减载机造停止叙说，减深对 Android 的了解。
行将教会

ART 战 Dalvik
Android 类减载流程
热建复完成道理

ART 取 Dalvik

JVM 取 DVM

JVM 是我们的 Java 假造机，而我们的Android使用运转正在 Dalvik/ART 假造机上的。每个使用对应一个 Dalvik 假造机，固然 Dalvik 假造机也算 Java 假造机，不外施行的没有是.class文件，而是dex文件。

那里对上述名词停止一些叙说
假造机分类

基于栈的假造机 每个运转的线程，皆有一个自力的栈，栈中记载了办法挪用的汗青，每个办法的挪用，皆对应一个栈帧，而且将栈帧压进栈中，最顶部的栈帧为当前栈帧，既当前施行的办法，基于栈帧取操纵数栈停止一切操纵。
存放器 CPU的构成部门，存放器是有限存储容量的下速存储容器（计较机中各级存储速率存放器-> 一级缓存->两级缓存 -> 内乱存 -> 硬盘），能够用去办理指令、数据的地点。
基于存放器的假造机 （模仿存放器的操纵流程）
基于存放器的假造机中出有操纵数栈，不外有许多假造存放器，相同操纵数栈，那些存放器也寄存正在运转时栈中，素质上便是一个数组，取JVM类似，正在Dalvik 假造机中每一个线程皆有本人的PC 战挪用栈，办法挪用的举动记载以帧为单元保留正在挪用栈上。
差别假造机流程

我们比照一下基于栈的流程战基于存放器的流程

JVM流程阐发参考之前文章阐发,凡是需求颠末以下操纵

如将栈顶某范例值存进部分变量某处
将部分变量中某处某范例常量压进操纵数栈
施行相干指令

DVM 中，间接根据指令，将某范例值存进假造存放器中，相干的操纵也根据指令正在假造存放器中经由过程CPU处置，将处置成果返回假造存放器（免却了基于栈的流程中部分变量取操纵数栈中数据的活动）

ART 取 Dalvik 区分

ART 战 Dalvik 皆是基于存放器的假造机
Dalvik 施行 dex字节码，注释施行，正在Android2.2 开端，撑持立即编译，既挑选法式中常常施行的代码（又称热门代码），停止编译战劣化削减了JVM中注释的流程。
ART假造机（Android4.4）间接跑机械码，没有停止字节码注释。Android的运转时从Dalvik 无影响过渡ART，由于并不用开辟者将使用间接编译成目的机械码，APk照旧是一个包含dex字节码的文件。
为何APK照旧是包含dex字节码的文件，而ART战 Dalvik的施行方法纷歧样?

那里ART间接跑字节码，而Dalvik停止注释施行，并正在2.2引进JIT，可是皆是dex文件。
由于APK文件需求正在Android体系中运转，需求停止装置，那个时分，颠末假造机，会对dex停止劣化，Dalvik中，会将dex字节码停止劣化天生odex文件，而ART 会将 dex字节码翻译为当地机械码（引进了预先编译机造 Ahead of Time），装置时，ART利用装备自带的dex2oat东西对使用停止编译。dex中的字节码被编译成本天机械码，那也是为何我们装置的时分比力缓。
不外前面从Android O 开端，装置速率变快了，由于那个时分接纳混淆编译了，JIT、AOT、战字节码注释。当使用初次装置时，没有停止AOT编译，运转过程当中接纳注释施行，并将法式中常常要施行的代码停止立即编译（JIT），并将JIT编译后的办法记载到Profile设置文件，当装备忙置时，利用编译保护过程，根据Profile文件对经常使用文件停止AOT编译（天生.art文件），以便下次运转时间接利用。假如下次法式运转，将检测该文件并剖析出机械码中文件中的类疑息，减载到ClassLoader中。
ClassLoader 及类减载流程

ClassLoader

每个Java法式皆是有一个或多个class文件构成，正在法式运转时，需求将class文件减载到JVM中才可使用，而减载class文件的是Java的类减载机造，ClassLoader减载class文件供给法式运转时利用，每一个Class工具内乱部皆有一个classLoader字段去标识由何种classLoader减载。
ClassLoader 类和类构造

ClassLoader
BootClassLoader 用于减载Android Framework 层 Class文件（像String.Class）
PathClassLoader 持续自ClassLoader 用于Android使用法式减载类

类减载流程

PathClassLoader

上面我们阐发一下PathClassLoader类去阐发类减载流程

/**
* Loads the class with the specified <a href="#name">binary name</a>. The
* default implementation of this method searches for classes in the
*/
// Android-removed: Remove references to getClassLoadingLock
// Remove perf counters.
//
// <p> Unless overridden, this method synchronizes on the result of
// {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method
// during the entire class loading process.
//
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
//找缓存，曾经减载过的便没有会被减载了
//class文件需求转换为class工具耗时操纵
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
//出有缓存进if
if (c == null) {
try {
//假如该类下的parent工具真例没有为空，操纵该parent工具减载相干类
//该工具指背 BootClassLoader 以下图所示
if (parent != null) {
c = parent.loadClass(name, false);
} else {
//parent 为空，返回空
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.
//假如 parent（BootstrapClass）中减载没有到该类
//则挪用本身findClass来减载类(PathClassLoader)
c = findClass(name);
}
}
//有缓存间接返回
return c;
}
/**
* Returns a class loaded by the bootstrap class loader;
* or return null if not found.
*/
private Class<?> findBootstrapClassOrNull(String name)
{
return null;
}

复造代码

我们能够经由过程上述代码阐发战 PathClassLoader类构造图获得该类的loadClass流程

那末为何我们ClassLoader中要停止如许的设想呢？
起首，那个parent的目标正在于完成类减载的单亲拜托，起首减载使命拜托给女类减载器，顺次递回，假如女类减载器能够完成类减载使命，则胜利返回，只要女类减载器没法完成此减载使命时，才本人来完成减载。而完成这类机造，能够到达以下结果

制止反复减载，当parent对应的减载器曾经减载了该类的时分，便出有必有当前classloader再减载一次,间接正在parent中的缓存找。
宁静思索，避免核心API被窜改，像本人界说一个String.java 那个时分classloader会先减载framework中的String.java（减载只需齐限制名一样，能够假造构建战体系类一样的齐限制名）

上里我们阐发了它的设想思惟，回回减载过程当中，那里用到了findClass(name) 办法
findClass(name) 又做了甚么？
我们能够经由过程检察其本身战女类寻觅findClass办法，经由过程检察

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
//经由过程pathList 来找相干类，而pathList 是 DexPathList 是 final 的
Class c = pathList.findClass(name, suppressedExceptions);
//明白了返回 Class相干真例工具，出找到扔非常枢纽正在上一止代码
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;
}
//上述pathList 声明是不成变的我们来检察其赋值
private final DexPathList pathList;
//pathList 又是由甚么赋值能够看到相干利用正在机关办法中
// 经由过程检察其机关办法，可知我们需求传进 dexPath 来真例化 DexPathList
// 因而PathClassLoader才能够减载到法式的一切类
/**
* @hide
*/
public BaseDexClassLoader(String dexPath, File optimizedDirectory,
String librarySearchPath, ClassLoader parent, boolean isTrusted) {
super(parent);
//我们跳来 DexPathList 看看
this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);
if (reporter != null) {
reportClassLoaderChain();
}
}
// 我们看一下DexPathList
DexPathList(ClassLoader definingContext, String dexPath,
String librarySearchPath, File optimizedDirectory, boolean isTrusted) {
//通例参数判空
if (definingContext == null) {
throw new NullPointerException("definingContext == null");
}
if (dexPath == null) {
throw new NullPointerException("dexPath == null");
}
if (optimizedDirectory != null) {
if (!optimizedDirectory.exists()) {
throw new IllegalArgumentException(
"optimizedDirectory doesn't exist: "
+ optimizedDirectory);
}
if (!(optimizedDirectory.canRead()
&& optimizedDirectory.canWrite())) {
throw new IllegalArgumentException(
"optimizedDirectory not readable/writable: "
+ optimizedDirectory);
}
}
this.definingContext = definingContext;
ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
// save dexPath for BaseDexClassLoader
// 那里利用到了 dexpath
// splitDexPath 将dexpath的多地点别离 , PathClassLoader 能够处置多个dex
// makeDexElements 根据dexpath天生多个dexElement
// 上面我们来看一下splitDexPath 战 makeDexElements
this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
suppressedExceptions, definingContext, isTrusted);
this.nativeLibraryDirectories = splitPaths(librarySearchPath, false);
this.systemNativeLibraryDirectories =
splitPaths(System.getProperty("java.library.path"), true);
List<File> allNativeLibraryDirectories = new ArrayList<>(nativeLibraryDirectories);
allNativeLibraryDirectories.addAll(systemNativeLibraryDirectories);
this.nativeLibraryPathElements = makePathElements(allNativeLibraryDirectories);
if (suppressedExceptions.size() > 0) {
this.dexElementsSuppressedExceptions =
suppressedExceptions.toArray(new IOException[suppressedExceptions.size()]);
} else {
dexElementsSuppressedExceptions = null;
}
}
//splitDexPath 办法
private static List<File> splitDexPath(String path) {
return splitPaths(path, false);
}
/**
* Splits the given path strings into file elements using the path
* separator, combining the results and filtering out elements
* that don't exist, aren't readable, or aren't either a regular
* file or a directory (as specified). Either string may be empty
* or {@code null}, in which case it is ignored. If both strings
* are empty or {@code null}, or all elements get pruned out, then
* this returns a zero-element list.
*/
private static List<File> splitPaths(String searchPath, boolean directoriesOnly) {
List<File> result = new ArrayList<>();
if (searchPath != null) {
for (String path : searchPath.split(File.pathSeparator)) {
if (directoriesOnly) {
try {
StructStat sb = Libcore.os.stat(path);
if (!S_ISDIR(sb.st_mode)) {
continue;
}
} catch (ErrnoException ignored) {
continue;
}
}
result.add(new File(path));
}
}
return result;
}
//makePathElements 办法
private static final String zipSeparator = "!/";
private static NativeLibraryElement[] makePathElements(List<File> files) {
// 一个dex 天生一个 elements 工具
NativeLibraryElement[] elements = new NativeLibraryElement[files.size()];
int elementsPos = 0;
for (File file : files) {
String path = file.getPath();
if (path.contains(zipSeparator)) {
String split[] = path.split(zipSeparator, 2);
File zip = new File(split[0]);
String dir = split[1];
elements[elementsPos++] = new NativeLibraryElement(zip, dir);
} else if (file.isDirectory()) {
// We support directories for looking up native libraries.
elements[elementsPos++] = new NativeLibraryElement(file);
}
}
if (elementsPos != elements.length) {
elements = Arrays.copyOf(elements, elementsPos);
}
return elements;
}

复造代码

那里，我们了解到了pathList那个工具为了findClass做了甚么筹办，如今，我们回到BaseClassLoader 中的 findClass 办法中，持续看pathList那一止代码，pathList那个真例我们曾经晓得了，如今看它挪用的findClass办法（战BaseClassLoader中纷歧样）

//正在那里,我们能够看到该办法利用到了方才 pathList 中 dexElements数组
// 经由过程遍历每个 Element 遍历一切的dex
// DexFile dex = element.dexFile; 拿到对应的 DexFile
// dex.loadClassBinaryName(name, definingContext, suppressed);
// 再经由过程每一个dex 的 loadClassBinaryName 来将类找出
/**
* Finds the named class in one of the dex files pointed at by
* this instance. This will find the one in the earliest listed
* path element. If the class is found but has not yet been
* defined, then this method will define it in the defining
* context that this instance was constructed with.
*
* @param name of class to find
* @param suppressed exceptions encountered whilst finding the class
* @return the named class or {@code null} if the class is not
* found in any of the dex files
*/
public Class findClass(String name, List<Throwable> suppressed) {
for (Element element : dexElements) {
DexFile dex = element.dexFile;
if (dex != null) {
Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
if (clazz != null) {
return clazz;
}
}
}
if (dexElementsSuppressedExceptions != null) {
suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
}
return null;
}

复造代码

大抵的类减载流程便如上所示
热建回复复兴理

那末，经由过程类减载流程，我们那个时分能够正在那之长进止一下热建复

当我们法式有Bug时，我们对相干类停止修正，并将修正后的类挨包成补钉dex，当客户端下载时，只需让补钉包减载正在类减载之前，就能够提早减载到假造机中，而有毛病的类，由于类减载机造成绩，没有会反复减载，从而没有会减载到毛病类，进而完成建复。
热建回复复兴理大抵代码流程

//相干一般建复类挨补钉包
dx --dex --output=output.dex xxx.jar
dx --dex --output=output.dex 类齐限制名
正在Application类中重写 attachBaseContext 并正在super后挪用热建复
并传进Application，补钉dex文件至热建复类
//热建复类中
//1、得到classloader（PathClassLoader）
ClassLoader classLoader = application.getClassLoader();
//2\. 差别的Android 版本，热建复有所差别，需求对其适配（以6.0为例）
//3\. 遍历该类及超类
Class<?> clazz = classLoader.getClass(); clazz != null; clazz = clazz.getSuperclass()
//4.经由过程反射获得 pathList 属性成员
Field field = clazz.getDeclaredField("pathList");
//5.获得到pathList工具
Object dexPathList = pathListField.get(classLoader);
///将本人的补钉包转换为Element数组参考PathClassLoader
// 获得补钉包的Element数组
// 反射拿到 makePathElements 办法
Class<?> clazz = dexPathList.getClass(); clazz != null; clazz = clazz.getSuperclass()
Method method = clazz.getDeclaredMethod("makePathElements", parameterTypes);
//反射施行办法返回补钉包对应的 Element数组
Object[] patchElements = (Object[]) method.invoke(dexPathList, files, optimizedDirectory,
suppressedExceptions)
//将本来的 dexElements 取 makePathElements天生的数组兼并,并操纵反射塞回 dexElements
//拿到 classloader中的dexelements 数组
Class<?> clazz = dexPathList.getClass(); clazz != null; clazz = clazz.getSuperclass()
Field dexElementsField = clazz.getDeclaredField("dexElements");
//old Element[]
Object[] dexElements = (Object[]) dexElementsField.get(dexPathList);
//兼并后的数组
Object[] newElements = (Object[]) Array.newInstance(dexElements.getClass().getComponentType(),
dexElements.length + patchElements.length);
// 先拷贝新数组
System.arraycopy(patchElements, 0, newElements, 0, patchElements.length);
System.arraycopy(dexElements, 0, newElements, patchElements.length, dexElements.length);
//修正 classLoader中 pathList的 dexelements
dexElementsField.set(dexPathList, newElements);

复造代码

上述只是根据类减载道理进而对热建回复复兴理停止论述的大抵流程，完成热建复借需求思索到一下兼容成绩、肴纯等内乱容。

免责声明：假如进犯了您的权益，请联络站少，我们会实时删除侵权内乱容，感谢协作！

【Android食用指南-01】Android虚拟机&类加载机制

浏览过的版块