Android系統啓動流程（二）解析Zygote進程

時間  2019-11-24
標籤 android 系統 啓動 流程 解析 zygote 進程 欄目 Android 简体版
原文   原文鏈接

相關文章
Android系統架構與系統源碼目錄
Android系統啓動流程（一）解析init進程
前言
上一篇文章咱們分析了init進程，init進程中主要作了三件事，其中一件就是建立了Zygote進程，那麼Zygote進程是什麼，它作了哪些事呢？這篇文章會給你這些問題的答案。javascript

1.Zygote簡介

在Android系統中，JavaVM(Java虛擬機)、應用程序進程以及運行系統的關鍵服務的SystemServer進程都是由Zygote進程來建立的，咱們也將它稱爲孵化器。它經過fock(複製進程)的形式來建立應用程序進程和SystemServer進程，因爲Zygote進程在啓動時會建立JavaVM，所以經過fock而建立的應用程序進程和SystemServer進程能夠在內部獲取一個JavaVM的實例拷貝。
關於init啓動zygote咱們在上一篇文章已經提到了，這裏就不贅述了，這篇文章主要分析Android7.0 Zygote的啓動流程。java

2.AppRuntime分析

咱們從上篇文章得知init啓動zygote時主要是調用app_main.cpp的main函數中的AppRuntime的start來啓動zygote進程的，咱們就從app_main.cpp的main函數開始分析，以下所示。
frameworks/base/cmds/app_process/app_main.cppandroid

int main(int argc, char* const argv[])
{
...

    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
   ...
     Vector<String8> args;
    if (!className.isEmpty()) {
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);
    } else {
        // We're in zygote mode.
        maybeCreateDalvikCache();
        if (startSystemServer) {
            args.add(String8("start-system-server"));//1
        }
        char prop[PROP_VALUE_MAX];
        if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
            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);
        for (; i < argc; ++i) {
            args.add(String8(argv[i]));
        }
    }
    if (!niceName.isEmpty()) {
        runtime.setArgv0(niceName.string());
        set_process_name(niceName.string());
    }
    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);//2
    } 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.");
        return 10;
    }
}複製代碼

註釋1處若是startSystemServer爲true的話(默認爲true)，將"start-system-server"放入啓動的參數args。
註釋2處調用註釋2處這裏調用runtime的start函數來啓動zygote進程，並將args傳入，這樣啓動zygote進程後，zygote進程會將SystemServer進程啓動。咱們知道runtime指的就是AppRuntime，AppRuntime聲明也在app_main.cpp中，它繼承AndroidRuntime，也就是咱們調用start實際上是調用AndroidRuntime的start函數：數組

frameworks/base/core/jni/AndroidRuntime.cpp微信

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ...
    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {//1
        return;
    }
    onVmCreated(env);
    if (startReg(env) < 0) {//2
        ALOGE("Unable to register all android natives\n");
        return;
    }
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    //建立數組
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    assert(strArray != NULL);
    //從app_main的main函數得知className爲com.android.internal.os.ZygoteInit
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);

    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);
    }
    char* slashClassName = toSlashClassName(className);
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
    //找到ZygoteInit的main函數
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");//3
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
        //經過JNI調用ZygoteInit的main函數
            env->CallStaticVoidMethod(startClass, startMeth, strArray);//4

#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
  ...
}複製代碼

註釋1處調用startVm函數來建立JavaVm，註釋2處調用startReg函數用來爲JavaVm註冊JNI。註釋3處的代碼用來找到ZygoteInit的main函數，其中startClass從app_main的main函數得知爲com.android.internal.os.ZygoteInit。註釋4處經過JNI調用ZygoteInit的main函數，由於ZygoteInit的main函數是Java編寫的，所以須要經過JNI調用。架構

3.Zygote的Java框架層

上文咱們經過JNI調用ZygoteInit的main函數後，Zygote便進入了Java框架層，此前沒有任何代碼進入過Java框架層，換句換說Zygote開創了Java框架層。
frameworks/base/core/java/com/android/internal/os/ZygoteInit.javaapp

public static void main(String argv[]) {
       ...
        try {
         ...       
            //註冊Zygote用的Socket
            registerZygoteSocket(socketName);//1
           ...
           //預加載類和資源
           preload();//2
           ...
            if (startSystemServer) {
            //啓動SystemServer進程
                startSystemServer(abiList, socketName);//3
            }
            Log.i(TAG, "Accepting command socket connections");
            //等待客戶端請求
            runSelectLoop(abiList);//4
            closeServerSocket();
        } catch (MethodAndArgsCaller caller) {
            caller.run();
        } catch (RuntimeException ex) {
            Log.e(TAG, "Zygote died with exception", ex);
            closeServerSocket();
            throw ex;
        }
    }複製代碼

註釋1處經過registerZygoteSocket函數來建立一個Server端的Socket，這個Socket用來等待ActivityManagerService來請求Zygote來建立新的應用程序進程。註釋2處用來預加載類和資源。註釋3處用來啓動SystemServer進程，這樣系統的關鍵服務也會由SystemServer進程啓動起來。註釋4處調用runSelectLoop函數來等待客戶端請求。由此得知，ZygoteInit的main函數主要作了4件事，接下來咱們對主要的事件一一進行分析。框架

registerZygoteSocket
首先咱們來查看registerZygoteSocket函數作了什麼socket

private static void registerZygoteSocket(String socketName) {
        if (sServerSocket == null) {
            int fileDesc;
            final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
            try {
                String env = System.getenv(fullSocketName);
                fileDesc = Integer.parseInt(env);
            } catch (RuntimeException ex) {
                throw new RuntimeException(fullSocketName + " unset or invalid", ex);
            }
            try {
                FileDescriptor fd = new FileDescriptor();
                fd.setInt$(fileDesc);
                sServerSocket = new LocalServerSocket(fd);//1
            } catch (IOException ex) {
                throw new RuntimeException(
                        "Error binding to local socket '" + fileDesc + "'", ex);
            }
        }複製代碼

註釋1處用來建立LocalServerSocket，也就是服務端的Socket。當Zygote進程將SystemServer進程啓動後，就會在這個服務端的Socket上來等待ActivityManagerService請求Zygote進程來建立新的應用程序進程。函數

啓動SystemServer進程
接下來查看startSystemServer函數，代碼以下所示。

private static boolean startSystemServer(String abiList, String socketName)
            throws MethodAndArgsCaller, RuntimeException {
...
        /* Hardcoded command line to start the system server */
         /*1*/
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007,3009,3010",
            "--capabilities=" + capabilities + "," + capabilities,
            "--nice-name=system_server",
            "--runtime-args",
            "com.android.server.SystemServer",
        };
        ZygoteConnection.Arguments parsedArgs = null;

        int pid;

        try {
            parsedArgs = new ZygoteConnection.Arguments(args);//2
            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

            /*3*/
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            handleSystemServerProcess(parsedArgs);//4
        }

        return true;
    }複製代碼

註釋1處的代碼用來建立args數組，這個數組用來保存啓動SystemServer的啓動參數，其中能夠看出SystemServer進程的用戶id和用戶組id被設置爲1000；而且擁有用戶組1001~1010，101八、102一、103二、3001~3010的權限；進程名爲system_server；啓動的類名爲com.android.server.SystemServer。在註釋2處將args數組封裝成Arguments對象並供註釋3的forkSystemServer函數調用。註釋3處調用Zygote的forkSystemServer，主要經過fork函數在當前進程建立一個子進程，若是返回的pid 爲0，也就是表示在新建立的子進程中執行的，則執行註釋4處的handleSystemServerProcess來啓動SystemServer進程。

runSelectLoop
啓動啓動SystemServer進程後，最後進入runSelectLoop函數，以下所示。

private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
        ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
        ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
        fds.add(sServerSocket.getFileDescriptor());//1
        peers.add(null);

        while (true) {
            StructPollfd[] pollFds = new StructPollfd[fds.size()];
            for (int i = 0; i < pollFds.length; ++i) {//2
                pollFds[i] = new StructPollfd();
                pollFds[i].fd = fds.get(i);
                pollFds[i].events = (short) POLLIN;
            }
            try {
                Os.poll(pollFds, -1);
            } catch (ErrnoException ex) {
                throw new RuntimeException("poll failed", ex);
            }
            for (int i = pollFds.length - 1; i >= 0; --i) {//3
                if ((pollFds[i].revents & POLLIN) == 0) {
                    continue;
                }
                if (i == 0) {
                    ZygoteConnection newPeer = acceptCommandPeer(abiList);//4
                    peers.add(newPeer);
                    fds.add(newPeer.getFileDesciptor());
                } else {
                    boolean done = peers.get(i).runOnce();//5
                    if (done) {
                        peers.remove(i);
                        fds.remove(i);
                    }
                }
            }
        }
    }複製代碼

註釋1處中的sServerSocket就是咱們在registerZygoteSocket函數中建立的服務端Socket，調用sServerSocket.getFileDescriptor()用來得到該Socket的fd字段的值並添加到fd列表fds中。接下來無限循環用來等待ActivityManagerService請求Zygote進程建立新的應用程序進程。註釋2處經過遍歷將fds存儲的信息轉移到pollFds數組中。最後在註釋3處對pollFds進行遍歷，若是i==0則說明服務端Socket與客戶端鏈接上，也就是當前Zygote進程與ActivityManagerService創建了鏈接。則在註釋4處經過acceptCommandPeer函數獲得ZygoteConnection類並添加到Socket鏈接列表peers中，接着將該ZygoteConnection的fd添加到fd列表fds中，以即可以接收到ActivityManagerService發送過來的請求。若是i的值大於0，則說明ActivityManagerService向Zygote進程發送了一個建立應用進程的請求，則在註釋5處調用ZygoteConnection的runOnce函數來建立一個新的應用程序進程。並在成功建立後將這個鏈接從Socket鏈接列表peers和fd列表fds中清除。

4.Zygote進程總結

Zygote啓動流程就講到這，Zygote進程共作了以下幾件事：
1.建立AppRuntime並調用其start方法，啓動Zygote進程。
2.建立JavaVM併爲JavaVM註冊JNI.
3.經過JNI調用ZygoteInit的main函數進入Zygote的Java框架層。
4.經過registerZygoteSocket函數建立服務端Socket，並經過runSelectLoop函數等待ActivityManagerService的請求。
5.啓動SystemServer進程。

參考資料
《Android系統源代碼情景分析》
《深刻理解Android卷1》
《深刻理解Android系統》

歡迎關注個人微信公衆號，第一時間得到博客更新提醒，以及更多成體系的Android相關原創技術乾貨。
掃一掃下方二維碼或者長按識別二維碼，便可關注。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程