ndroid 4.4发布了一个ART运行时，准备用来替换掉之前一直使用的Dalvik虚拟机，希望籍此解决饱受诟病的性能问题。老罗不打算分析ART的实现原理，只是很有兴趣知道ART是如何无缝替换掉原来的Dalvik虚拟机的。毕竟在原来的系统中，大量的代码都是运行在Dalvik虚拟机里面的。开始觉得这个替换工作是挺复杂的，但是分析了相关代码之后，发现思路是很清晰的。本文就详细分析这个无缝的替换过程。

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

        我们知道，Dalvik虚拟机实则也算是一个Java虚拟机，只不过它执行的不是class文件，而是dex文件。因此，ART运行时最理想的方式也是实现为一个Java虚拟机的形式，这样就可以很容易地将Dalvik虚拟机替换掉。注意，我们这里说实现为Java虚拟机的形式，实际上是指提供一套完全与Java虚拟机兼容的接口。例如，Dalvik虚拟机在接口上与Java虚拟机是一致的，但是它的内部可以是完全不一样的东西。

         实际上，ART运行时就是真的和Dalvik虚拟机一样，实现了一套完全兼容Java虚拟机的接口。为了方便描述，接下来我们就将ART运行时称为ART虚拟机，它和Dalvik虚拟机、Java虚拟机的关系如图1所示：


图1 Java虚拟机、Dalvik虚拟机和ART运行时的关系

        从图1可以知道，Dalvik虚拟机和ART虚拟机都实现了三个用来抽象Java虚拟机的接口：

       1. JNI_GetDefaultJavaVMInitArgs -- 获取虚拟机的默认初始化参数

       2. JNI_CreateJavaVM -- 在进程中创建虚拟机实例

       3. JNI_GetCreatedJavaVMs -- 获取进程中创建的虚拟机实例

       在Android系统中，Davik虚拟机实现在libdvm.so中，ART虚拟机实现在libart.so中。也就是说，libdvm.so和libart.so导出了JNI_GetDefaultJavaVMInitArgs、JNI_CreateJavaVM和JNI_GetCreatedJavaVMs这三个接口，供外界调用。

       此外，Android系统还提供了一个系统属性persist.sys.dalvik.vm.lib，它的值要么等于libdvm.so，要么等于libart.so。当等于libdvm.so时，就表示当前用的是Dalvik虚拟机，而当等于libart.so时，就表示当前用的是ART虚拟机。

       以上描述的Dalvik虚拟机和ART虚拟机的共同之处，当然它们之间最显著还是不同之处。不同的地方就在于，Dalvik虚拟机执行的是dex字节码，ART虚拟机执行的是本地机器码。这意味着Dalvik虚拟机包含有一个解释器，用来执行dex字节码，具体可以参考Dalvik虚拟机简要介绍和学习计划这个系列的文章。当然，Android从2.2开始，也包含有JIT（Just-In-Time），用来在运行时动态地将执行频率很高的dex字节码翻译成本地机器码，然后再执行。通过JIT，就可以有效地提高Dalvik虚拟机的执行效率。但是，将dex字节码翻译成本地机器码是发生在应用程序的运行过程中的，并且应用程序每一次重新运行的时候，都要做重做这个翻译工作的。因此，即使用采用了JIT，Dalvik虚拟机的总体性能还是不能与直接执行本地机器码的ART虚拟机相比。

        那么，ART虚拟机执行的本地机器码是从哪里来的呢？Android的运行时从Dalvik虚拟机替换成ART虚拟机，并不要求开发者要将重新将自己的应用直接编译成目标机器码。也就是说，开发者开发出的应用程序经过编译和打包之后，仍然是一个包含dex字节码的APK文件。既然应用程序包含的仍然是dex字节码，而ART虚拟机需要的是本地机器码，这就必然要有一个翻译的过程。这个翻译的过程当然不能发生应用程序运行的时候，否则的话就和Dalvik虚拟机的JIT一样了。在计算机的世界里，与JIT相对的是AOT。AOT进Ahead-Of-Time的简称，它发生在程序运行之前。我们用静态语言（例如C/C++）来开发应用程序的时候，编译器直接就把它们翻译成目标机器码。这种静态语言的编译方式也是AOT的一种。但是前面我们提到，ART虚拟机并不要求开发者将自己的应用直接编译成目标机器码。这样，将应用的dex字节码翻译成本地机器码的最恰当AOT时机就发生在应用安装的时候。

       我们知道，没有ART虚拟机之前，应用在安装的过程，其实也会执行一次“翻译”的过程。只不过这个“翻译”的过程是将dex字节码进行优化，也就是由dex文件生成odex文件。这个过程由安装服务PackageManagerService请求守护进程installd来执行的。从这个角度来说，在应用安装的过程中将dex字节码翻译成本地机器码对原来的应用安装流程基本上就不会产生什么影响。

        有了以上的背景知识之后，我们接下来就从两个角度来了解ART虚拟机是如何做到无缝替换Dalvik虚拟机的：

        1. ART虚拟机的启动过程；

        2. Dex字节码翻译成本地机器码的过程。

        我们知道，Android系统在启动的时候，会创建一个Zygote进程，充当应用程序进程孵化器。Zygote进程在启动的过程中，又会创建一个Dalvik虚拟机。Zygote进程是通过复制自己来创建新的应用程序进程的。这意味着Zygote进程会将自己的Dalvik虚拟机复制给应用程序进程。通过这种方式就可以大大地提高应用程序的启动速度，因为这种方式避免了每一个应用程序进程在启动的时候都要去创建一个Dalvik。事实上，Zygote进程通过自我复制的方式来创建应用程序进程，省去的不仅仅是应用程序进程创建Dalvik虚拟机的时间，还能省去应用程序进程加载各种系统库和系统资源的时间，因为它们在Zygote进程中已经加载过了，并且也会连同Dalvik虚拟机一起复制到应用程序进程中去。关于Zygote进程和应用程序进程启动的更多知识，可以参考Android系统进程Zygote启动过程的源代码分析和Android应用程序进程启动过程的源代码分析这两篇文章。

        即然应用程序进程里面的Dalvik虚拟机都是从Zygote进程中复制过来的，那么接下来我们就继续Zygote进程是如何创建Dalvik虚拟机的。从Dalvik虚拟机的启动过程分析这篇文章可以知道，Zygote进程中的Dalvik虚拟机是从AndroidRutime::start这个函数开始创建的。因此，接下来我们就看看这个函数的实现：

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void AndroidRuntime::start(const char* className, const char* options)  
  2. {  
  3.     ......  
  4.   
  5.     /* start the virtual machine */  
  6.     JniInvocation jni_invocation;  
  7.     jni_invocation.Init(NULL);  
  8.     JNIEnv* env;  
  9.     if (startVm(&mJavaVM, &env) != 0) {  
  10.         return;  
  11.     }  
  12.   
  13.     ......  
  14.   
  15.     /* 
  16.      * Start VM.  This thread becomes the main thread of the VM, and will 
  17.      * not return until the VM exits. 
  18.      */  
  19.     char* slashClassName = toSlashClassName(className);  
  20.     jclass startClass = env->FindClass(slashClassName);  
  21.     if (startClass == NULL) {  
  22.         ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);  
  23.         /* keep going */  
  24.     } else {  
  25.         jmethodID startMeth = env->GetStaticMethodID(startClass, "main",  
  26.             "([Ljava/lang/String;)V");  
  27.         if (startMeth == NULL) {  
  28.             ALOGE("JavaVM unable to find main() in '%s'\n", className);  
  29.             /* keep going */  
  30.         } else {  
  31.             env->CallStaticVoidMethod(startClass, startMeth, strArray);  
  32.   
  33. #if 0  
  34.             if (env->ExceptionCheck())  
  35.                 threadExitUncaughtException(env);  
  36. #endif  
  37.         }  
  38.     }  
  39.       
  40.     ......  
  41. }  
         这个函数定义在文件frameworks/base/core/jni/AndroidRuntime.cpp中。

          AndroidRutime类的成员函数start最主要是做了以下三件事情：

          1. 创建一个JniInvocation实例，并且调用它的成员函数init来初始化JNI环境；

          2. 调用AndroidRutime类的成员函数startVm来创建一个虚拟机及其对应的JNI接口，即创建一个JavaVM接口和一个JNIEnv接口；

          3. 有了上述的JavaVM接口和JNIEnv接口之后，就可以在Zygote进程中加载指定的class了。

          其中，第1件事情和第2件事情又是最关键的。因此，接下来我们继续分析它们所对应的函数的实现。

          JniInvocation类的成员函数init的实现如下所示：

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #ifdef HAVE_ANDROID_OS  
  2. static const char* kLibrarySystemProperty = "persist.sys.dalvik.vm.lib";  
  3. #endif  
  4. static const char* kLibraryFallback = "libdvm.so";  
  5.   
  6. bool JniInvocation::Init(const char* library) {  
  7. #ifdef HAVE_ANDROID_OS  
  8.   char default_library[PROPERTY_VALUE_MAX];  
  9.   property_get(kLibrarySystemProperty, default_library, kLibraryFallback);  
  10. #else  
  11.   const char* default_library = kLibraryFallback;  
  12. #endif  
  13.   if (library == NULL) {  
  14.     library = default_library;  
  15.   }  
  16.   
  17.   handle_ = dlopen(library, RTLD_NOW);  
  18.   if (handle_ == NULL) {  
  19.     if (strcmp(library, kLibraryFallback) == 0) {  
  20.       // Nothing else to try.  
  21.       ALOGE("Failed to dlopen %s: %s", library, dlerror());  
  22.       return false;  
  23.     }  
  24.     // Note that this is enough to get something like the zygote  
  25.     // running, we can't property_set here to fix this for the future  
  26.     // because we are root and not the system user. See  
  27.     // RuntimeInit.commonInit for where we fix up the property to  
  28.     // avoid future fallbacks. http://b/11463182  
  29.     ALOGW("Falling back from %s to %s after dlopen error: %s",  
  30.           library, kLibraryFallback, dlerror());  
  31.     library = kLibraryFallback;  
  32.     handle_ = dlopen(library, RTLD_NOW);  
  33.     if (handle_ == NULL) {  
  34.       ALOGE("Failed to dlopen %s: %s", library, dlerror());  
  35.       return false;  
  36.     }  
  37.   }  
  38.   if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetDefaultJavaVMInitArgs_),  
  39.                   "JNI_GetDefaultJavaVMInitArgs")) {  
  40.     return false;  
  41.   }  
  42.   if (!FindSymbol(reinterpret_cast<void**>(&JNI_CreateJavaVM_),  
  43.                   "JNI_CreateJavaVM")) {  
  44.     return false;  
  45.   }  
  46.   if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetCreatedJavaVMs_),  
  47.                   "JNI_GetCreatedJavaVMs")) {  
  48.     return false;  
  49.   }  
  50.   return true;  
  51. }  
        这个函数定义在文件libnativehelper/JniInvocation.cpp中。

        JniInvocation类的成员函数init所做的事情很简单。它首先是读取系统属性persist.sys.dalvik.vm.lib的值。前面提到，系统属性persist.sys.dalvik.vm.lib的值要么等于libdvm.so，要么等于libart.so。因此，接下来通过函数dlopen加载到进程来的要么是libdvm.so，要么是libart.so。无论加载的是哪一个so，都要求它导出JNI_GetDefaultJavaVMInitArgs、JNI_CreateJavaVM和JNI_GetCreatedJavaVMs这三个接口，并且分别保存在JniInvocation类的三个成员变量JNI_GetDefaultJavaVMInitArgs_、JNI_CreateJavaVM_和JNI_GetCreatedJavaVMs_中。这三个接口也就是前面我们提到的用来抽象Java虚拟机的三个接口。

        从这里就可以看出，JniInvocation类的成员函数init实际上就是根据系统属性persist.sys.dalvik.vm.lib来初始化Dalvik虚拟机或者ART虚拟机环境。

        接下来我们继续看AndroidRutime类的成员函数startVm的实现：

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv)  
  2. {  
  3.     ......  
  4.   
  5.     /* 
  6.      * Initialize the VM. 
  7.      * 
  8.      * The JavaVM* is essentially per-process, and the JNIEnv* is per-thread. 
  9.      * If this call succeeds, the VM is ready, and we can start issuing 
  10.      * JNI calls. 
  11.      */  
  12.     if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {  
  13.         ALOGE("JNI_CreateJavaVM failed\n");  
  14.         goto bail;  
  15.     }  
  16.   
  17.     ......  
  18. }  
         这个函数定义在文件frameworks/base/core/jni/AndroidRuntime.cpp中。

         AndroidRutime类的成员函数startVm最主要就是调用函数JNI_CreateJavaVM来创建一个JavaVM接口及其对应的JNIEnv接口：

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void* vm_args) {  
  2.   return JniInvocation::GetJniInvocation().JNI_CreateJavaVM(p_vm, p_env, vm_args);  
  3. }  
        这个函数定义在文件libnativehelper/JniInvocation.cpp中。

        JniInvocation类的静态成员函数GetJniInvocation返回的便是前面所创建的JniInvocation实例。有了这个JniInvocation实例之后，就继续调用它的成员函数JNI_CreateJavaVM来创建一个JavaVM接口及其对应的JNIEnv接口：

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. jint JniInvocation::JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void* vm_args) {  
  2.   return JNI_CreateJavaVM_(p_vm, p_env, vm_args);  
  3. }  
        这个函数定义在文件libnativehelper/JniInvocation.cpp中。

        JniInvocation类的成员变量JNI_CreateJavaVM_指向的就是前面所加载的libdvm.so或者libart.so所导出的函数JNI_CreateJavaVM，因此，JniInvocation类的成员函数JNI_CreateJavaVM返回的JavaVM接口指向的要么是Dalvik虚拟机，要么是ART虚拟机。

        通过上面的分析，我们就很容易知道，Android系统通过将ART运行时抽象成一个Java虚拟机，以及通过系统属性persist.sys.dalvik.vm.lib和一个适配层JniInvocation，就可以无缝地将Dalvik虚拟机替换为ART运行时。这个替换过程设计非常巧妙，因为涉及到的代码修改是非常少的。

        以上就是ART虚拟机的启动过程，接下来我们再分析应用程序在安装过程中将dex字节码翻译为本地机器码的过程。

         Android应用程序的安装过程可以参考Android应用程序安装过程源代码分析这篇文章。 简单来说，就是Android系统通过PackageManagerService来安装APK，在安装的过程，PackageManagerService会通过另外一个类Instalerl的成员函数dexopt来对APK里面的dex字节码进行优化：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public final class Installer {  
  2.     ......  
  3.   
  4.     public int dexopt(String apkPath, int uid, boolean isPublic) {  
  5.         StringBuilder builder = new StringBuilder("dexopt");  
  6.         builder.append(' ');  
  7.         builder.append(apkPath);  
  8.         builder.append(' ');  
  9.         builder.append(uid);  
  10.         builder.append(isPublic ? " 1" : " 0");  
  11.         return execute(builder.toString());  
  12.     }  
  13.   
  14.     ......  
  15. }  
         这个函数定义在文件frameworks/base/services/java/com/android/server/pm/Installer.java中。

         Installer通过socket向守护进程installd发送一个dexopt请求，这个请求是由installd里面的函数dexopt来处理的：

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. int dexopt(const char *apk_path, uid_t uid, int is_public)  
  2. {  
  3.     struct utimbuf ut;  
  4.     struct stat apk_stat, dex_stat;  
  5.     char out_path[PKG_PATH_MAX];  
  6.     char dexopt_flags[PROPERTY_VALUE_MAX];  
  7.     char persist_sys_dalvik_vm_lib[PROPERTY_VALUE_MAX];  
  8.     char *end;  
  9.     int res, zip_fd=-1, out_fd=-1;  
  10.   
  11.     ......  
  12.   
  13.     /* The command to run depend ones the value of persist.sys.dalvik.vm.lib */  
  14.     property_get("persist.sys.dalvik.vm.lib", persist_sys_dalvik_vm_lib, "libdvm.so");  
  15.   
  16.     /* Before anything else: is there a .odex file?  If so, we have 
  17.      * precompiled the apk and there is nothing to do here. 
  18.      */  
  19.     sprintf(out_path, "%s%s", apk_path, ".odex");  
  20.     if (stat(out_path, &dex_stat) == 0) {  
  21.         return 0;  
  22.     }  
  23.   
  24.     if (create_cache_path(out_path, apk_path)) {  
  25.         return -1;  
  26.     }  
  27.   
  28.     ......  
  29.   
  30.     out_fd = open(out_path, O_RDWR | O_CREAT | O_EXCL, 0644);  
  31.   
  32.     ......  
  33.   
  34.     pid_t pid;  
  35.     pid = fork();  
  36.     if (pid == 0) {  
  37.         ......  
  38.   
  39.         if (strncmp(persist_sys_dalvik_vm_lib, "libdvm", 6) == 0) {  
  40.             run_dexopt(zip_fd, out_fd, apk_path, out_path, dexopt_flags);  
  41.         } else if (strncmp(persist_sys_dalvik_vm_lib, "libart", 6) == 0) {  
  42.             run_dex2oat(zip_fd, out_fd, apk_path, out_path, dexopt_flags);  
  43.         } else {  
  44.             exit(69);   /* Unexpected persist.sys.dalvik.vm.lib value */  
  45.         }  
  46.         exit(68);   /* only get here on exec failure */  
  47.     }   
  48.   
  49.     ......  
  50. }  

         这个函数定义在文件frameworks/native/cmds/installd/commands.c中。

         函数dexopt首先是读取系统属性persist.sys.dalvik.vm.lib的值，接着在/data/dalvik-cache目录中创建一个odex文件。这个odex文件就是作为dex文件优化后的输出文件。再接下来，函数dexopt通过fork来创建一个子进程。如果系统属性persist.sys.dalvik.vm.lib的值等于libdvm.so，那么该子进程就会调用函数run_dexopt来将dex文件优化成odex文件。另一方面，如果系统属性persist.sys.dalvik.vm.lib的值等于libart.so，那么该子进程就会调用函数run_dex2oat来将dex文件优化成oart文件，实际上就是将dex字节码翻译成本地机器码，并且保存在一个oat文件中。

        函数run_dexopt和run_dex2oat的实现如下所示：

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. static void run_dexopt(int zip_fd, int odex_fd, const char* input_file_name,  
  2.     const char* output_file_name, const char* dexopt_flags)  
  3. {  
  4.     static const char* DEX_OPT_BIN = "/system/bin/dexopt";  
  5.     static const int MAX_INT_LEN = 12;      // '-'+10dig+'\0' -OR- 0x+8dig  
  6.     char zip_num[MAX_INT_LEN];  
  7.     char odex_num[MAX_INT_LEN];  
  8.   
  9.     sprintf(zip_num, "%d", zip_fd);  
  10.     sprintf(odex_num, "%d", odex_fd);  
  11.   
  12.     ALOGV("Running %s in=%s out=%s\n", DEX_OPT_BIN, input_file_name, output_file_name);  
  13.     execl(DEX_OPT_BIN, DEX_OPT_BIN, "--zip", zip_num, odex_num, input_file_name,  
  14.         dexopt_flags, (char*) NULL);  
  15.     ALOGE("execl(%s) failed: %s\n", DEX_OPT_BIN, strerror(errno));  
  16. }  
  17.   
  18. static void run_dex2oat(int zip_fd, int oat_fd, const char* input_file_name,  
  19.     const char* output_file_name, const char* dexopt_flags)  
  20. {  
  21.     static const char* DEX2OAT_BIN = "/system/bin/dex2oat";  
  22.     static const int MAX_INT_LEN = 12;      // '-'+10dig+'\0' -OR- 0x+8dig  
  23.     char zip_fd_arg[strlen("--zip-fd=") + MAX_INT_LEN];  
  24.     char zip_location_arg[strlen("--zip-location=") + PKG_PATH_MAX];  
  25.     char oat_fd_arg[strlen("--oat-fd=") + MAX_INT_LEN];  
  26.     char oat_location_arg[strlen("--oat-name=") + PKG_PATH_MAX];  
  27.   
  28.     sprintf(zip_fd_arg, "--zip-fd=%d", zip_fd);  
  29.     sprintf(zip_location_arg, "--zip-location=%s", input_file_name);  
  30.     sprintf(oat_fd_arg, "--oat-fd=%d", oat_fd);  
  31.     sprintf(oat_location_arg, "--oat-location=%s", output_file_name);  
  32.   
  33.     ALOGV("Running %s in=%s out=%s\n", DEX2OAT_BIN, input_file_name, output_file_name);  
  34.     execl(DEX2OAT_BIN, DEX2OAT_BIN,  
  35.           zip_fd_arg, zip_location_arg,  
  36.           oat_fd_arg, oat_location_arg,  
  37.           (char*) NULL);  
  38.     ALOGE("execl(%s) failed: %s\n", DEX2OAT_BIN, strerror(errno));  
  39. }  
         这两个函数定义在文件frameworks/native/cmds/installd/commands.c中。

         这从里就可以看出，函数run_dexopt通过调用/system/bin/dexopt来对dex字节码进行优化，而函数run_dex2oat通过调用/system/bin/dex2oat来将dex字节码翻译成本地机器码。注意，无论是对dex字节码进行优化，还是将dex字节码翻译成本地机器码，最终得到的结果都是保存在相同名称的一个odex文件里面的，但是前者对应的是一个dexy文件（表示这是一个优化过的dex），后者对应的是一个oat文件（实际上是一个自定义的elf文件，里面包含的都是本地机器指令）。通过这种方式，原来任何通过绝对路径引用了该odex文件的代码就都不需要修改了。

        通过上面的分析，我们就很容易知道，只需要将dex文件的优化过程替换成dex文件翻译成本地机器码的过程，就可以轻松地在应用安装过程，无缝地将Dalvik虚拟机替换成ART运行时。

        最后，还有一个地方需要注意的是，应用程序的安装发生在两个时机，第一个时机是系统启动的时候，第二个时机系统启动完成后用户自行安装的时候。在第一个时机中，系统除了会对/system/app和/data/app目录下的所有APK进行dex字节码到本地机器码的翻译之外，还会对/system/framework目录下的APK或者JAR文件，以及这些APK所引用的外部JAR，进行dex字节码到本地机器码的翻译。这样就可以保证除了应用之外，系统中使用Java来开发的系统服务，也会统一地从dex字节码翻译成本地机器码。也就是说，将Android系统中的Dalvik虚拟机替换成ART运行时之后，系统中的代码都是由ART运行时来执行的了，这时候就不会对Dalvik虚拟机产生任何的依赖。

        至此，我们就分析完成ART运行时无缝替换Dalvik虚拟机的过程了。

转载自：http://blog.csdn.net/luoshengyang/article/details/18006645

# android # dalvik
Logo
华为开发者空间

华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。

更多推荐

cover

优化大宽表查询性能，揭秘GaussDB(DWS) 谓词列analyze

avatar 华为开发者空间
cover

混合云网络过于复杂？ENS给你全局一张网的极致体验

avatar 华为开发者空间
cover

数据库高安全—openGauss安全整体架构&安全认证

avatar 华为开发者空间