0、引言

? ? ? ? Android的底层内核是基于Linux构建而成，是在Native世界，而Android上层的应用是隶属Java世界。那么在Android系统启动过程中，系统是如何从Native孵化出Java世界的呢？这便是这篇文章的主角Zygote的主要职责。

????????本文所选Android系统版本是9.0 Pie，文中所有代码片段路径在代码块第一行已经标注。文章的目的是记录自己的学习历程与心得，不做商用或盈利，凡是学习过程中学习或引用过的大佬博文或著作都会尽力标注，在此感谢各位前辈的不吝分享。本文借鉴如下：

1、C/C++中的Zygote

? ? ? ? 上篇文章《Android9.0(Pie)1号进程init的启动流程学习》中说到，Android系统的1号进程init会通过.rc配置文件启动其他进程，zygote也是此方式被启动的。不过在pie\system\core\rootdir\目录下有好几个zygote的rc文件，根据生产环境的设备的CPU配置不同，有init.zygote32.rc、init.zygote32_64.rc、init.zygote64.rc、init.zygote64_32.rc这几个选择。在init.rc头部可以看到其导入对应配置的rc文件时，是根据属性ro.zygote来控制的，由于我的生产环境该属性值为zygote32，所以?参考《Android系统init进程启动及init.rc全解析》和《Android源码之init.rc文件详解》?来看看init.zygote32.rc吧。

// pie\system\core\rootdir\init.zygote32.rc

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main    //该服务指定类属为main,这样方便操作多个服务同时启动或停止
    priority -20  //参考linux的进程优先级nice，取值范围【-20，19】，值越小优先级越高
    user root     //在执行此服务之前先切换用户名为root
    group root readproc reserved_disk    //类似于user,切换组名
    socket zygote stream 660 root system    //在目标机/dev/socket/目录下创建一个unix domain类型的socket，该socket文件命名为zygote，端口为660，运行该程序需要root或system权限
    onrestart write /sys/android_power/request_state wake    //该服务重启时，向指定文件中写入内容
    onrestart write /sys/power/state on
    onrestart restart audioserver    //该服务重启时，重启指定服务
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks    //创建子进程时向该文件中写入进程的pid

1.1、app_process

????????从第一行可以看出zygote只是对程序的重命名，实际运行的是目标机/system/bin目录下的app_process程序，其后面跟的是运行该程序所带的参数，即这个app_process是一个命令行程序，那么先找到这个程序的main函数，鉴于该函数较长，我们将主要代码分割成几个部分来看。

????????1.1.1、AndroidRuntime初始化

// pie\frameworks\base\cmds\app_process\app_main.cpp
int main(int argc, char* const argv[])
{
    if (!LOG_NDEBUG) {    //debug模式下打印一下传进来的参数，方便调试和定位问题
      String8 argv_String;
      for (int i = 0; i < argc; ++i) {
        argv_String.append("\"");
        argv_String.append(argv[i]);
        argv_String.append("\" ");
      }
      ALOGV("app_process main with argv: %s", argv_String.string());
    }

    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));    //调用父类AndroidRuntime的构造函数进行初始化
    argc--;
    argv++;    // 忽略程序名所占用的第一个参数argv[0]

    …………
}

????????这里的AppRuntime是继承的pie\frameworks\base\core\jni\AndroidRuntime.cpp，AppRuntime类的构造函数为空，所以转去调用父类AndroidRuntime的构造函数：

//    pie\frameworks\base\core\jni\AndroidRuntime.cpp
AndroidRuntime::AndroidRuntime(char* argBlockStart, const size_t argBlockLength) :
        mExitWithoutCleanup(false),       //使用命令行传进来的参数初始化该类的成员变量，
        mArgBlockStart(argBlockStart),    //首个参数起始位置，
        mArgBlockLength(argBlockLength)   //以及所有参数块所占内存大小
{
    init_android_graphics();              //初始化android图形功能
    mOptions.setCapacity(20);             //虚拟机启动时需要一些option作为参数，这里设置option数量
    assert(gCurRuntime == NULL);          //每个进程都要进行空指针检测
    gCurRuntime = this;    
}

????????1.1.2、spaced_commands? ? ? ? TODO

? ? ? ? 这一部分spaced_commands相关的内容有点不知所云，但又不影响往后分析，所以先放着，后面明白了再来补充，有大佬知道的也可以评论里补充下，不胜感激。

// pie\frameworks\base\cmds\app_process\app_main.cpp
int main(int argc, char* const argv[])
{
…………
 const char* spaced_commands[] = { "-cp", "-classpath" };
    bool known_command = false;

    int i;
    for (i = 0; i < argc; i++) {
        if (known_command == true) {
          runtime.addOption(strdup(argv[i]));
          ALOGV("app_process main add known option '%s'", argv[i]);
          known_command = false;
          continue;
        }

        for (int j = 0;
             j < static_cast<int>(sizeof(spaced_commands) / sizeof(spaced_commands[0]));
             ++j) {
          if (strcmp(argv[i], spaced_commands[j]) == 0) {
            known_command = true;
            ALOGV("app_process main found known command '%s'", argv[i]);
          }
        }

        if (argv[i][0] != '-') {
            break;
        }
        if (argv[i][1] == '-' && argv[i][2] == 0) {
            ++i; // Skip --.
            break;
        }

        runtime.addOption(strdup(argv[i]));
        ALOGV("app_process main add option '%s'", argv[i]);
    }
}

????????1.1.3、参数解析

// pie\frameworks\base\cmds\app_process\app_main.cpp
int main(int argc, char* const argv[])
{
…………
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;
    String8 className;

    ++i;  // 跳过没有用到的参数"/system/bin"
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {    //解析到参数"--zygote"时，
            zygote = true;                     //说明为zygote模式
            niceName = ZYGOTE_NICE_NAME;       //准备app_process进程的别名ZYGOTE_NICE_NAME="zygote"
        } else if (strcmp(arg, "--start-system-server") == 0) {    //解析到参数"--start-system-server"时
            startSystemServer = true;                              //需要启动system_server
        } else if (strcmp(arg, "--application") == 0) {    //如果参数中有"--application"，
            application = true;                            //则为application模式
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
            niceName.setTo(arg + 12);                      //application模式下设置别名
        } else if (strncmp(arg, "--", 2) != 0) {
            className.setTo(arg);                          //application模式下设置类名
            break;
        } else {
            --i;
            break;
        }
    }

    Vector<String8> args;
    if (!className.isEmpty()) {    //非zygote模式下，传递参数"application"给RuntimeInit
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);    //传递类名和剩余参数

        if (!LOG_NDEBUG) {
          String8 restOfArgs;
          char* const* argv_new = argv + i;
          int argc_new = argc - i;
          for (int k = 0; k < argc_new; ++k) {
            restOfArgs.append("\"");
            restOfArgs.append(argv_new[k]);
            restOfArgs.append("\" ");
          }
          ALOGV("Class name = %s, args = %s", className.string(), restOfArgs.string());
        }
    } else {    //zygote模式下
        maybeCreateDalvikCache();                        //创建/data/dalvik-cache/目录
        if (startSystemServer) {
            args.add(String8("start-system-server"));    //传递参数"start-system-server"
        }

        char prop[PROP_VALUE_MAX];
        if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {    //读取abi接口list
            LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
                ABI_LIST_PROPERTY);
            return 11;
        }

        String8 abiFlag("--abi-list=");
        abiFlag.append(prop);
        args.add(abiFlag);                 //传递系统支持的CPU架构类型参数"--abi-list=armeabi-v7a,armeabi,……"

        for (; i < argc; ++i) {
            args.add(String8(argv[i]));    //传递剩余的参数
        }
    }
}

? ? ? ? ?这里主要是针对main函数传递进来的参数，解析zygote模式和application模式下的相关参数，根据参数进行设置类名、进程别名、置位标识、传递参数到AndroidRuntime等动作。

? ? ? ? 1.1.4、runtime.start()

// pie\frameworks\base\cmds\app_process\app_main.cpp
int main(int argc, char* const argv[])
{
…………
    if (!niceName.isEmpty()) {    
        runtime.setArgv0(niceName.string(), true);    //设置进程的别名为前面准备好的niceName
    }

    if (zygote) {    //zygote模式
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);    //调用父类AndroidRuntime的start()函数
    } else if (className) {    //application模式
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
}

? ? ? ? 这里主要是为app_process进程设置别名，然后调用runtime.start()调用父类AndroidRuntime的start()函数，该函数的功能我们后面再看。到此位置的函数调用情况如下图所示：

1.2、AndroidRuntime::start()

? ? ? ? 1.2.1、环境变量相关

? ? ? ? 这个函数依然分割开来看，第一部分比较简单，就做了一些事件打印，和环境变量相关的设置与检测。

// pie\frameworks\base\core\jni\AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ALOGD(">>>>>> START %s uid %d <<<<<<\n",
            className != NULL ? className : "(unknown)", getuid());
    static const String8 startSystemServer("start-system-server");
    bool primary_zygote = false;
    for (size_t i = 0; i < options.size(); ++i) {
        if (options[i] == startSystemServer) {
            primary_zygote = true;
           const int LOG_BOOT_PROGRESS_START = 3000;
           LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));    //带时间打印一下startSystemServer事件
        }
    }

    const char* rootDir = getenv("ANDROID_ROOT");
    if (rootDir == NULL) {
        rootDir = "/system";
        if (!hasDir("/system")) {
            LOG_FATAL("No root directory specified, and /system does not exist.");
            return;
        }
        setenv("ANDROID_ROOT", rootDir, 1);    //设置环境变量
    }

    const char* artRootDir = getenv("ANDROID_ART_ROOT");    //检查环境变量
    if (artRootDir == NULL) {
        LOG_FATAL("No ART directory specified with ANDROID_ART_ROOT environment variable.");
        return;
    }

    const char* i18nRootDir = getenv("ANDROID_I18N_ROOT");
    if (i18nRootDir == NULL) {
        LOG_FATAL("No runtime directory specified with ANDROID_I18N_ROOT environment variable.");
        return;
    }

    const char* tzdataRootDir = getenv("ANDROID_TZDATA_ROOT");
    if (tzdataRootDir == NULL) {
        LOG_FATAL("No tz data directory specified with ANDROID_TZDATA_ROOT environment variable.");
        return;
    }
    …………
}

? ? ? ? 1.2.2、加载虚拟机库

// // pie\frameworks\base\core\jni\AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
…………
JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    …………
}

? ? ? ? ?接下来能看到的就是JniInvocation类，该类相关定义位于pie/libnativehelper/目录下，其主要功能是向外部提供了动态调用虚拟机内部的相关接口。首先来看代码中调用的Init()函数：

// pie\libnativehelper\JniInvocation.cpp
bool JniInvocation::Init(const char* library) {
#ifdef __ANDROID__
  char buffer[PROP_VALUE_MAX];
#else
  char* buffer = NULL;
#endif
  library = GetLibrary(library, buffer);      //获取默认库libart.so
   //RTLD_NOW：dlopen函数的打开模式为立即解析出所有未定义符号，如果解析不出来，在dlopen会返回NULL
   //RTLD_NODELETE：在dlclose()期间不卸载库，因为即使在JNI_DeleteJavaVM返回后，一些线程可能还没有完成退出，如果卸载库，这可能会导致段错误  
  const int kDlopenFlags = RTLD_NOW | RTLD_NODELETE;
  handle_ = dlopen(library, kDlopenFlags);    //打开libart.so库，获取到句柄
  if (handle_ == NULL) {                      //如果打开失败，则再尝试一次，确保正常打开libart.so
    if (strcmp(library, kLibraryFallback) == 0) {
      ALOGE("Failed to dlopen %s: %s", library, dlerror());
      return false;
    }
    ALOGW("Falling back from %s to %s after dlopen error: %s", library, kLibraryFallback, dlerror());
    library = kLibraryFallback;
    handle_ = dlopen(library, kDlopenFlags);
    if (handle_ == NULL) {
      ALOGE("Failed to dlopen %s: %s", library, dlerror());
      return false;
    }
  }
  //FindSymbol()函数通过调用dlsym()函数，获取JNI_GetDefaultJavaVMInitArgs、JNI_CreateJavaVM、JNI_GetCreatedJavaVMs这三个函数的地址
  if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetDefaultJavaVMInitArgs_), "JNI_GetDefaultJavaVMInitArgs")) {
    return false;
  }
  if (!FindSymbol(reinterpret_cast<void**>(&JNI_CreateJavaVM_), "JNI_CreateJavaVM")) {
    return false;
  }
  if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetCreatedJavaVMs_), "JNI_GetCreatedJavaVMs")) {
    return false;
  }
  return true;
}

? ? ? ? 可以看出Init函数主要功能就是寻找并打开默认虚拟机库，并根据打开文件句柄获取到库中几个关键函数的指针。需要说明下的是，这里GetLibrary()去获取的默认库是虚拟机的库，在较早的版本比如4.4 kitkak中使用的是dalvik虚拟机，所以获取的默认库是libdvm.so，在之后的高版本中就有art虚拟机了，所以默认库就是libart.so。两者的主要区别主要是art虚拟机把字节码的翻译优化从运行时提前到安装时，?以空间换时间，从而优化运行加载时间。

????????1.2.3、启动JavaVM

// pie\libnativehelper\JniInvocation.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ………… 
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
        return;
    }
    onVmCreated(env);    //空接口
    …………
}

? ? ? ? 首先出现的JNIEnv是在JNI编程中经常会出现的东西，其相关的定义是在文件pie\libnativehelper\include_jni\jni.h中，所以这里也是为后面注册JNI函数做准备。先来看startVm()函数，其主要功能就是创建JavaVM，该函数中有很多addOption(操作，这里截取一部分进行说明。

// pie\frameworks\base\core\jni\AndroidRuntime.cpp
int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote, bool primary_zygote)
{
    JavaVMInitArgs initArgs;
    …………
    addOption(***);    //此处省略一大堆通过属性值或配置来向Vector<JavaVMOption> mOptions中添加的动作
    …………

    //对结构体JavaVMInitArgs的成员赋值
    initArgs.version = JNI_VERSION_1_4;
    initArgs.options = mOptions.editArray();
    initArgs.nOptions = mOptions.size();
    initArgs.ignoreUnrecognized = JNI_FALSE;
    
    //调用前面打开的libart.so库中的JNI_CreateJavaVM函数以创建JavaVM。
    //JavaVM*本质上是每个进程的，而JNIEnv*是每个线程的。如果这里创建成功，就可以发出JNI调用了。
    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {   
        ALOGE("JNI_CreateJavaVM failed\n");
        return -1;
    }
    return 0;
}

? ? ? ? 1.2.4、注册JNI函数

// pie\libnativehelper\JniInvocation.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    …………
    if (startReg(env) < 0) {    //注册JNI函数
        ALOGE("Unable to register all android natives\n");
        return;
    }
    …………
}

// pie\libnativehelper\JniInvocation.cpp
int AndroidRuntime::startReg(JNIEnv* env)
{
    ATRACE_NAME("RegisterAndroidNatives");
    //设置Threads.cpp中创建线程的函数为javaCreateThreadEtc
    androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);

    ALOGV("--- registering native functions ---\n");
    
    //每个注册函数都会返回一个或多个native引用的对象，此时虚拟机还没有完全启动起来，
    //所以这里先用Frame管理局部引用的生命周期，参数200是为了足够的空间来存储。
    env->PushLocalFrame(200);
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {    //JNI函数注册动作
        env->PopLocalFrame(NULL);
        return -1;
    }
    env->PopLocalFrame(NULL);

    return 0;
}

? ? ? ? ?参考《android系统核心机制基础（02）Thread类解析》，可知这里的androidSetCreateThreadFunc()函数是pie\system\core\libutils\Threads.cpp中的函数，这里的动作是将Threads类中创建线程的函数从androidCreateRawThreadEtc()设置为了AndroidRuntime.cpp中定义的javaCreateThreadEtc()。虽说最终调用的还是androidCreateRawThreadEtc()函数，但线程函数改为了AndroidRuntime.cpp中的javaThreadShell()函数。

// pie\frameworks\base\core\jni\AndroidRuntime.cpp
int AndroidRuntime::javaCreateThreadEtc(
                                android_thread_func_t entryFunction,
                                void* userData,
                                const char* threadName,
                                int32_t threadPriority,
                                size_t threadStackSize,
                                android_thread_id_t* threadId)
{
    void** args = (void**) malloc(3 * sizeof(void*));   //javaThreadShell()函数中使用完后要记得free
    int result;
    LOG_ALWAYS_FATAL_IF(threadName == nullptr, "threadName not provided to javaCreateThreadEtc");

    args[0] = (void*) entryFunction;
    args[1] = userData;
    args[2] = (void*) strdup(threadName);   // javaThreadShell()函数中使用完后要记得free

    //最终还是调用androidCreateRawThreadEtc()，但将线程函数设置为了javaThreadShell()
    result = androidCreateRawThreadEtc(AndroidRuntime::javaThreadShell, args,  
              threadName, threadPriority, threadStackSize, threadId);    
    return result;
}

// 线程函数
int AndroidRuntime::javaThreadShell(void* args) {
    void* start = ((void**)args)[0];
    void* userData = ((void **)args)[1];
    char* name = (char*) ((void **)args)[2];
    free(args);    //释放上面javaCreateThreadEtc函数中malloc的args
    JNIEnv* env;
    int result;

    if (javaAttachThread(name, &env) != JNI_OK)    //使当前创建的线程对VM可见
        return -1;
    result = (*(android_thread_func_t)start)(userData);    //运行创建的该线程

    javaDetachThread();    //线程退出时将当前线程从虚拟机可见的线程集中分离
    free(name);

    return result;
}

? ? ? ? androidSetCreateThreadFunc()函数分析完后，我们往下看比较重要的register_jni_procs()函数，其主要功能就是注册JNI函数了：

// pie\frameworks\base\core\jni\AndroidRuntime.cpp
static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
{
    //传递进来的RegJNIRec类型的数组gRegJNI里面存储的全是一些注册函数的函数指针，
    //所以执行RegJNIRec的成员mProc，相当于执行对应的函数，去完成每个函数的注册动作。
    for (size_t i = 0; i < count; i++) {
        if (array[i].mProc(env) < 0) {    
#ifndef NDEBUG
            ALOGD("----------!!! %s failed to load\n", array[i].mName);
#endif
            return -1;
        }
    }
    return 0;
}

// RegJNIRec的定义
#ifdef NDEBUG
    #define REG_JNI(name)      { name }
    struct RegJNIRec {
        int (*mProc)(JNIEnv*);
    };
#else
    #define REG_JNI(name)      { name, #name }
    struct RegJNIRec {
        int (*mProc)(JNIEnv*);
        const char* mName;
    };
#endif

//截取部分gRegJNI数组内容
static const RegJNIRec gRegJNI[] = {
REG_JNI(register_com_android_internal_os_RuntimeInit),
        REG_JNI(register_com_android_internal_os_ZygoteInit_nativeZygoteInit),
        REG_JNI(register_android_os_SystemClock),
        REG_JNI(register_android_util_CharsetUtils),
        …………
}

? ? ? ? 1.2.5、准备Java main函数的形参argv

? ? ? ? 准备要进入Java世界、调用Java的main函数了，但需要先把将要执行main函数的类名"com.android.internal.os.ZygoteInit"，和前面添加的虚拟机设置相关的一堆option传递过去，所以这里需要准备一下，以String[]的形式传递。

// pie\frameworks\base\core\jni\AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    …………
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;

    stringClass = env->FindClass("java/lang/String");    //先找到Java的String类
    assert(stringClass != NULL);
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);    //相当于strArray = new String[options.size() + 1];
    assert(strArray != NULL);
    //字符串需要转换为Java世界的UTF格式,相当于classNameStr = new String("com.android.internal.os.ZygoteInit");
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);    //相当于strArray[0] = classNameStr; 即"com.android.internal.os.ZygoteInit"
    
    //把存储在Vector中的所有option都转换为Java世界的String类型，顺序存储到strArray中[1, options.size()]的位置
    for (size_t i = 0; i < options.size(); ++i) {
        jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
        assert(optionsStr != NULL);
        env->SetObjectArrayElement(strArray, i + 1, optionsStr);
    }
    …………
}

? ? ? ? 1.2.6、启动虚拟机

// pie\frameworks\base\core\jni\AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    …………
    //将"com.android.internal.os.ZygoteInit"转化为"com/android/internal/os/ZygoteInit"格式
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName);    //根据路径找到ZygoteInit类
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
    } else {
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");    //找到ZygoteInit类的static main方法
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
        } else {
            env->CallStaticVoidMethod(startClass, startMeth, strArray);    //执行ZygoteInit.main()函数
#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
    …………
}

? ? ? ? 这里的动作就很好理解了，无非就是找到com/android/internal/os/ZygoteInit.java，然后执行该类的main函数，自此将进入Java世界。需要注意理解的是，根据代码中的注释，这里就是启动虚拟机的过程，当前线程也就成为了虚拟机的主线程，所以这个函数只有在虚拟机退出（比如崩溃）的时候才会return。

????????1.2.7、退出时释放资源

// pie\frameworks\base\core\jni\AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    …………
    free(slashClassName);                            //释放字符串所占空间

    ALOGD("Shutting down VM\n");                     //虚拟机崩溃或退出的时候才会执行到这里
    if (mJavaVM->DetachCurrentThread() != JNI_OK)    //将当前线程从虚拟机可见的线程集中分离
        ALOGW("Warning: unable to detach main thread\n");
    if (mJavaVM->DestroyJavaVM() != 0)               //销毁前面创建的JavaVM
        ALOGW("Warning: VM did not shut down cleanly\n");
}

? ? ? ? 到此，Zygote进程的C/C++部分的代码就先告一段落了，后面就要进入Java世界了。Java部分也有很多内容需要说明，鉴于之前写的几篇篇幅过长的博文观感不佳，所以这篇博文先写到这里，Zygote 的Java部分放在下一篇博文《Zygote——Android系统中java世界的受精卵（二、Welcome To Java）》中来详细分析吧。老规矩，结尾一图总结一下调用流程：