Android FrameWork之Zygote启动示例详解寻技术

1、Zygote介绍

Zygote是一个进程，当开机引导内核启动之后，首先用户空间的第一个进程Init进程被启动，接着Init进程会启动Zygote进程。

Zygote进程作为一个孵化器，主要用于fork新的进程，比如用于系统服务的SystemServer进程，我们的APP进程等。

而Zygote在启动的时候会创建启动我们的Java虚拟机，而Zygote通过fork出的进程也会拥有父进程一样的功能，也就拥有我们的Java虚拟机环境。

所以我们常说的在安卓系统中每个进程拥有一个虚拟机的缘由是这样来的，当然除了非Zygote fork的进程。

2、Zygote的启动脚本

脚本路径：system/core/rootdir/init.zygote32.rc

脚本内容：

    service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc
    socket zygote stream 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

脚本的第一行大概可以看出，Zygote的进程名为 zygote ，执行程序为app_process ，class name为main，我们去找到对应的app_process 。

路径：frameworks/base/cmds/app_process

在app_process的路径下有一个app_main.cpp的文件：

frameworks/base/cmds/app_process/app_main.cpp

由此可以猜到这里可以作为zygote 进程启动的代码入口。

3、app_process app_main.cpp源码分析

frameworks/base/cmds/app_process/app_main.cpp

我们找到app_main.cpp其main函数

int main(int argc, char* const argv[])
{
    ....
   // 1、创建了AppRuntime 对象
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    // Process command line arguments
    // ignore argv[0]
    argc--;
    argv++;
    // Parse runtime arguments.  Stop at first unrecognized option.
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;
    String8 className;
    ++i;  // Skip unused "parent dir" argument.
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
        } else if (strcmp(arg, "--application") == 0) {
            application = true;
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
            niceName.setTo(arg + 12);
        } else if (strncmp(arg, "--", 2) != 0) {
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }
 ......
 ......
    if (zygote) {
      //2、调用runtime的start函数
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        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.");
    }
}

main函数的核心功能主要是创建了AppRuntime runtime对象，并调用start方法，这里传入的className参数是com.android.internal.os.ZygoteInit（全类名）
AppRuntime 继承了AndroidRuntime，我们看AndroidRuntime中的start函数。

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ....
   ....
   ....
    /* start the virtual machine 3、启动Java虚拟机*/
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);
    .....
   /*
     * Register android functions.
      *Register android native functions with the VM.
     * 4、向虚拟机注册android本地函数。
     */
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
  .....
   .....
.....
    /*
     * Start VM.  This thread becomes the main thread of the VM, and will
     * not return until the VM exits.
     */
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
        //5、使用env对象，通过JNI调用startClass这个类的main函数，
        //而startClass这个类就是之前传起来的 
        //com.android.internal.os.ZygoteInit
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
    }

以上的流程主要就是：

创建AppRuntime对象，调用其start函数。
在start函数中首先调用startVm函数启动Java虚拟机
启动Java虚拟机之后调用startReg函数，注册JNI
通过JNI调用ZygoteInit类的main函数
之后就从Native进入了Java是世界

4、ZygoteInit.java源码分析

frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

public static void main(String argv[]) {
      //1、创建一个ZygoteServer对象
        ZygoteServer zygoteServer = new ZygoteServer();
        final Runnable caller;
        try {
            ....
            ....
            boolean startSystemServer = false;
            String socketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {
                    startSystemServer = true;
                } else if ("--enable-lazy-preload".equals(argv[i])) {
                    enableLazyPreload = true;
                } else if (argv[i].startsWith(ABI_LIST_ARG)) {
                    abiList = argv[i].substring(ABI_LIST_ARG.length());
                } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
                    socketName = argv[i].substring(SOCKET_NAME_ARG.length());
                } else {
                    throw new RuntimeException("Unknown command line argument: " + argv[i]);
                }
            }
           //2、注册一个本地ServerSocket,名为 "zygote"
            zygoteServer.registerServerSocket(socketName);
                if (!enableLazyPreload) {
                bootTimingsTraceLog.traceBegin("ZygotePreload");
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
                    SystemClock.uptimeMillis());
              //preload执行预加载，在preload函数中主要调用了 
              //preloadClasses和 preloadResources();加载一些系统资源和系统类，
                preload(bootTimingsTraceLog);
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
                    SystemClock.uptimeMillis());
                bootTimingsTraceLog.traceEnd(); // ZygotePreload
            } else {
                Zygote.resetNicePriority();
            }
            if (startSystemServer) {
              //调用fork函数，启创建启动SystemServer进程
                Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
                // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
                // child (system_server) process.
              //这句很关键如果在父进程zygote，则返回null,如果在system_server进程则不会null，
              //所以当在zygote进程的之后，该条件不满足
                if (r != null) {
                    r.run();
                    return;
                }
            }
            Log.i(TAG, "Accepting command socket connections");
            // The select loop returns early in the child process after a fork and
            // loops forever in the zygote.
          //在zygote进程中，调用runSelectLoop进入无线循环,如果是子进程则返回caller 对象
            caller = zygoteServer.runSelectLoop(abiList);
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            throw ex;
        } finally {
          //如果不是在zygote进程则退出循环进入到这里，关闭socket server
            zygoteServer.closeServerSocket();
        }
        // We're in the child process and have exited the select loop. Proceed to execute the
        // command.
      //如果是在子进程中，通过返回的caller 对象，调用caller 的run函数。
        if (caller != null) {
            caller.run();
        }
    }

在ZygoteInit的main函数中主要做了以下工作：

创建并注册一个名为"zygote"本地SocketServer，也就是此时Zygote进程作为LocalSocket的服务端
在preload函数中的调用preloadClasses和preloadResources函数预加载系统类和一些系统资源
调用forkSystemServer创建启动SystemServer进程并返回了一个Runnable r对象，此时就同时拥有了Zygote和SystemServer进程在运行，不通进程它们分别执行不同的代码分支
如果是在SystemServer进程则直接执行 r.run函数并return，在Zygote进程则往下走，调用了zygoteServer中的runSelectLoop函数，进入无限循环，注释也描述了如果是在其他子进程的话，则该循环会退出，返回一个Runnable caller对象。并且往下走调用caller.run函数。

5、小结

Zygote进程的启动主要做了以下一些工作
Native层

创建启动Java虚拟机
注册JNI
通过JNI调用ZygoteInit.java的main函数
Java层
创建并注册名为"zygote"本地SocketServer，用于进程之间通信，Zygote进程作为服务端，其实目的就是为了和之后的SystemServer进程通信
预加载一些类和一些资源
fork子进程SystemServer
runSelectLoop进入无线循环

以上就是Android FrameWork之Zygote启动示例详解的详细内容，更多关于Android FrameWork Zygote启动的资料请关注寻技术其它相关文章！

本文地址：https://www.xunjs.com/android/view_18183.html

Tags： framework 详解 Android 启动示例