Android源码分析--Zygote进程分析

众所周知，Android系统中存在着两个完全不同的世界：
1. Java世界，Google所提供的SDK就主要是针对这个世界的，在这个世界中运行的程序都是基于Dalvik虚拟机的Java程序。
2. native世界，也就是利用C或C++语言开发的程序。

那么问题来了，Android系统具体是如何将这两个世界联系起来的，这就是关系到本篇博文所讲的Zygote进程。Android是基于Linux内核构建的，这样Android最早进入的也就是native世界。Linux系统启动的第一个进程是init进程，Android系统中最早启动的进程也是init进程，接下来init进程根据init.rc文件中的配置选项创建了Zygote进程。

Zygote名字的来历

Zygote进程的名字最初时并不是“zygote”，而是“app_process”，这个名字是在Android.mk文件中指定的，但在运行过程中app_process通过Linux下pctrl系统调用把名字换成了“zygote”。其所对应的源文件是App_main.cpp。

App_main.cpp分析

（源码位置：frameworks\base\cmds\app_process\app_main.cpp）
被执行的方法是App_main.cpp中的main方法，该方法比较简单，它首先为虚拟机添加了一些参数，接下来解析了运行时的参数，如果我们的参数设定为执行Zygote进程，则会将bool值zygote置为true，接下来调用了AppRuntime中的start方法。

int main(int argc, char* const argv[])
{
    ........
    // 两个全局变量被定义在ProcessState.cpp中
    mArgC = argc;
    mArgV = argv;

    mArgLen = 0;
    for (int i=0; i<argc; i++) {
        mArgLen += strlen(argv[i]) + 1;
    }
    mArgLen--;

    AppRuntime runtime;
    const char* argv0 = argv[0];

    // Process command line arguments
    // ignore argv[0]
    argc--;
    argv++;

    // Everything up to ‘--‘ or first non ‘-‘ arg goes to the vm

    int i = runtime.addVmArguments(argc, argv);

    // 接下来解析一些运行时参数
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    const char* parentDir = NULL;
    const char* niceName = NULL;
    const char* className = NULL;
    while (i < argc) {
        const char* arg = argv[i++];
        if (!parentDir) {
            parentDir = arg;
        } else if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = "zygote";
        } 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 = arg + 12;
        } else {
            className = arg;
            break;
        }
    }

    if (niceName && *niceName) {
        setArgv0(argv0, niceName);
        //在这里将进程的名称更换为zygote
        set_process_name(niceName);
    }

    runtime.mParentDir = parentDir;

    if (zygote) {
        // 调用AppRuntime的start方法以执行名称为ZygoteInit的类其中的main方法。
        // argv的参数为"--zygote" "--start-system-server",则startSystemServer为true
        runtime.start("com.android.internal.os.ZygoteInit", startSystemServer ? "start-system-server" : "");
    } else if (className) {

        runtime.mClassName = className;
        runtime.mArgC = argc - i;
        runtime.mArgV = argv + i;
        runtime.start("com.android.internal.os.RuntimeInit",
                application ? "application" : "tool");
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
        return 10;
    }
}

AppRuntime中start方法分析

在App_main的main方法中我们最终进入到AppRuntime的start方法中去，接下来分析一下AppRuntime中的start方法，该类的实现和定义均在app_main.cpp中。

//传入参数为"com.android.internal.os.ZygoteInit"，"start-system-server"
void AndroidRuntime::start(const char* className, const char* options)
{
    ALOGD("\n>>>>>> AndroidRuntime START %s <<<<<<\n",
            className != NULL ? className : "(unknown)");

    /*
     * ‘startSystemServer == true‘ 我们在这里打印出启动引导事件
     */
    if (strcmp(options, "start-system-server") == 0) {
        /* track our progress through the boot sequence */
        const int LOG_BOOT_PROGRESS_START = 3000;
        LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,
                       ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
    }
    //如果环境变量中没有ANDROID_ROOT则设置该环境变量
    const char* rootDir = getenv("ANDROID_ROOT");
    if (rootDir == NULL) {
        rootDir = "/system";
        if (!hasDir("/system")) {
            LOG_FATAL("No root directory specified, and /android does not exist.");
            return;
        }
        setenv("ANDROID_ROOT", rootDir, 1);
    }

    /* 开启虚拟机 */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env) != 0) {
        return;
    }
    onVmCreated(env);

    /*
     * 注册一些jni函数
     */
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

    /*
     * 接下来通过jni调用，调用ZygoteInit的main方法，并设置好传递参数
     */
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;
    jstring optionsStr;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    strArray = env->NewObjectArray(2, stringClass, NULL);
    assert(strArray != NULL);
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);
    optionsStr = env->NewStringUTF(options);
    env->SetObjectArrayElement(strArray, 1, optionsStr);

    /*
     * 该线程将会成为虚拟机的主线程，并且伴随虚拟机一直存在
     */
    char* slashClassName = toSlashClassName(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 {
        //调用Java类中的静态main方法
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
        .......
    }
    free(slashClassName);
    ......
}

我们来总结一下start方法的工作：
1. 设置ANDROID_ROOT环境变量
2. 调用AndroidRuntime类中的startVM方法创建虚拟机
3. 调用startReg函数注册JNI函数
4. 通过jni调用调用Java类ZygoteInit的main方法
至此，我们已经进入了Java的世界。

进入Java世界

通过上面的分析，我们的程序已经来到了Java类ZygoteInit的静态main方法中，该类被定义在frameworks\base\core\java\com\android\internal\os\ZygoteInit.java中。接下来我们看看她的工作：

    public static void main(String argv[]) {
        try {
            // 开始配置Zygote进程的初始化工作
            SamplingProfilerIntegration.start();

            //建立IPC通信的服务端
            registerZygoteSocket();
            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
                SystemClock.uptimeMillis());
            //预加载类和资源
            preload();
            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
                SystemClock.uptimeMillis());

            // 结束配置Zygote的初始化
            SamplingProfilerIntegration.writeZygoteSnapshot();

            // 进行一次垃圾回收
            gc();

            // 禁用跟踪
            Trace.setTracingEnabled(false);

            // If requested, start system server directly from Zygote
            if (argv.length != 2) {
                throw new RuntimeException(argv[0] + USAGE_STRING);
            }

            if (argv[1].equals("start-system-server")) {
                startSystemServer();//启动system_server进程
            } else if (!argv[1].equals("")) {
                throw new RuntimeException(argv[0] + USAGE_STRING);
            }

            Log.i(TAG, "Accepting command socket connections");

            runSelectLoop();//处理客户连接和客户请求

            closeServerSocket();//关闭服务端
        } catch (MethodAndArgsCaller caller) {
            caller.run();
        } catch (RuntimeException ex) {
            Log.e(TAG, "Zygote died with exception", ex);
            closeServerSocket();
            throw ex;
        }
    }

总结一下：
1. 调用registerZygoteSocket注册IPC通信服务端的socket
2. preload预加载类和资源
3. startSystemServer启动system_server
4. runSelectLoop处理客户连接和客户请求
在这里zygote进程建立了一个子进程system_server，该进程是framework的核心，并且和Zygote保持相同的生命周期。但是，system_server的作用将在runSelectLoop中体现出来。

runSelectLoop分析

在前面我们知道runSelectLoop被用来处理客户连接和客户请求，接下来我们来看看这个方法。

    private static void runSelectLoop() throws MethodAndArgsCaller {
        ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
        ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
        FileDescriptor[] fdArray = new FileDescriptor[4];

        fds.add(sServerSocket.getFileDescriptor());
        peers.add(null);

        int loopCount = GC_LOOP_COUNT;
        while (true) {
            int index;

            /*
             * Call gc() before we block in select().
             * It‘s work that has to be done anyway, and it‘s better
             * to avoid making every child do it.  It will also
             * madvise() any free memory as a side-effect.
             *
             * Don‘t call it every time, because walking the entire
             * heap is a lot of overhead to free a few hundred bytes.
             */
            if (loopCount <= 0) {
                gc();
                loopCount = GC_LOOP_COUNT;
            } else {
                loopCount--;
            }

            try {
                fdArray = fds.toArray(fdArray);
                //selectReadable是一个native方法，内部使用的是select使用多路复用I/O模型
                index = selectReadable(fdArray);
            } catch (IOException ex) {
                throw new RuntimeException("Error in select()", ex);
            }

            if (index < 0) {
                throw new RuntimeException("Error in select()");
            } else if (index == 0) {
                ZygoteConnection newPeer = acceptCommandPeer();
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
            } else {
                boolean done;
                done = peers.get(index).runOnce();

                if (done) {
                    peers.remove(index);
                    fds.remove(index);
                }
            }
        }
    }

在这段程序中我们可以发现每一次客户的连接中，客户是由ZygoteConnection对象来表示，客户的请求是由ZygoteConnection的runOnce方法来处理。

至此，我们对Zygote进程的分析以及结束，它运行起漫长的runSelectLoop方法就沉沉的睡去，接下来的重要任务将在system_server进程中处理执行。
参考书目：深入理解Android 卷I