Android小知識-深入淺出Android系統啟動流程（下）

本篇文章已授權微信公眾號 顧林海 獨家釋出

Zygote程式啟動過程

在Android系統中，所有的應用程式及系統服務SystemServer程式都由Zygote程式通過Linux的for()函式孵化出來的，因此我們稱Zygote是孵化器。

在前面知道了init啟動Zygote的相關操作在app_main.cpp的main函式中的，程式碼如下：

int main(int argc, char* const argv[])
{
    ...
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            //註釋1
            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("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函式中通過前面的if條件判斷語句來區分當前執行在哪個程式，如果是Zygote程式，就會在註釋1處將zygote賦值為true，同時執行註釋2處的runtime的start函式。

Zygote程式孵化子程式是通過自己的資源複製一份，來fork一個新的子程式，也就是說子程式進入這個檔案的main函式，因此，這裡的main函式被呼叫並不只是Zygote啟動的時候呼叫。既然子程式啟動的時候同樣被呼叫，那麼怎麼區分是被Zygote程式本身呼叫的還是它的子程式呼叫的呢？這裡就通過zygote這個變數來區分，如果是Zygote程式本身，變數zygote為true，否則就會進入到下面的else if裡，代表子程式啟動。

runtime是一個AppRuntime物件，AppRuntime類繼承AndroidRuntime類，因此前面呼叫的是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;
    //啟動Java虛擬機器
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);

    //註冊JNI方法
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

    ...
    //註釋1
    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);
    }

    //將className中的“.”替換成“/”
    //註釋2
    char* slashClassName = toSlashClassName(className);
    //註釋3
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ...
    } else {
        //註釋4
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
           ...
        } else {
            //註釋5
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

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

AndroidRuntime的start函式主要做了以下幾件事：

• 通過startVm函式啟動Java虛擬機器。
• 通過startReg函式註冊JNI方法。
• 呼叫com.android.internal.os.ZygoteInit類的main函式。

其中註釋1處的傳遞過來的className值是com.android.internal.os.ZygoteInit，在註釋2處將className中的“.”全部替換為“/”，替換後的值是com/android/internal/os/ZygoteInit，在註釋3處獲取ZygoteInit類，在註釋4處獲取ZygoteInit的main方法，最後在註釋5處通過JNI呼叫ZygoteInit的main方法，至此我們進入Java框架層。

ZygoteInit類的main方法如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static void main(String argv[]) {
        ZygoteServer zygoteServer = new ZygoteServer();

        ...

        try {
            ...
            //註釋1
            zygoteServer.registerServerSocket(socketName);

            if (!enableLazyPreload) {
                ...
                //註釋2
                preload(bootTimingsTraceLog);
                ...
            } else {
                Zygote.resetNicePriority();
            }

            ...
            //註釋3
            if (startSystemServer) {
                startSystemServer(abiList, socketName, zygoteServer);
            }

            //註釋4
            zygoteServer.runSelectLoop(abiList);

            zygoteServer.closeServerSocket();
        } catch (Zygote.MethodAndArgsCaller caller) {
            caller.run();
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            zygoteServer.closeServerSocket();
            throw ex;
        }
    }
複製程式碼

ZygoteInit的main方法中，註釋1處通過registerServerSocket方法建立一個Zygote的Socket介面用來和AMS通訊。檢視registerServerSocket方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
    void registerServerSocket(String socketName) {
        if (mServerSocket == null) {
            ...

            try {
                ...
                //註釋1
                mServerSocket = new LocalServerSocket(fd);
            } catch (IOException ex) {
                throw new RuntimeException(
                        "Error binding to local socket '" + fileDesc + "'", ex);
            }
        }
    }
複製程式碼

註釋1處建立了一個Java層的LocalServerSocket物件ServerSocket，用於等待建立新的應用程式程式請求連線。

ZygoteInit的main方法中，註釋2處通過preload方法預載入類和資源，如果系統不預載入類和資源，每次啟動一個應用程式都會去載入這些類和資源，那麼啟動應用程式的時間就會很長。

ZygoteInit的main方法中，註釋3處通過startSystemServer方法啟動SystemServer程式。檢視startSystemServer方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //註釋1
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,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
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        //註釋3
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket();
            //註釋4
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }
複製程式碼

註釋1處args陣列儲存的是SystemServer的啟動引數，最後封裝成Arguments物件，在註釋2處通過Zygote的forkSystemServer方法建立子程式，該方法內部會呼叫nativeForkSystemServer這個Native方法，nativeForkSystemServer方法最終通過fork函式建立一個子程式。在註釋3處，判斷pid是否等於0，如果等於0，說明當前的程式碼執行在新建立的子程式中，最後通過註釋4處的handleSystemServerProcess方法啟動SystemServer程式。

ZygoteInit的main方法中，註釋4處呼叫runSlectLoop方法，通過前面建立的Socket介面，進入一個無限迴圈，等待核心服務ActivityManagerService請求建立新的應用程式程式。檢視runSlectLoop方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
    void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
        ...

        while (true) {
            StructPollfd[] pollFds = new StructPollfd[fds.size()];
            for (int i = 0; i < pollFds.length; ++i) {
                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) {
                if ((pollFds[i].revents & POLLIN) == 0) {
                    continue;
                }
                //註釋1處
                if (i == 0) {
                    ZygoteConnection newPeer = acceptCommandPeer(abiList);
                    peers.add(newPeer);
                    fds.add(newPeer.getFileDesciptor());
                } else {
                    boolean done = peers.get(i).runOnce(this);
                    if (done) {
                        peers.remove(i);
                        fds.remove(i);
                    }
                }
            }
        }
    }
複製程式碼

在註釋1處，如果i==0，說明Zygote的Socket服務還沒準備好，接下來通過acceptCommandPeer方法得到ZygoteConnection物件，並新增到Socket連線列表peers中，同時將這個ZygoteConnection的fd新增到fd列表fds中，以便可以接收到AMS傳送過來的請求。如果i!=0，說明正在等待客戶端來連線服務端的Socket，當AMS向Zygote程式傳送一個建立應用程式程式的請求時，就會呼叫ZygoteConnection的runOnce()函式來建立應用程式程式的請求，成功建立後從Socket連線列表peers和fd列表中清除這個連線。

SystemServer程式

SystemServer程式主要用於建立系統服務，比如AMS、WMS和PMS都是由它來建立的，SystemServer程式與普通的應用程式程式執行在不同的程式裡面，應用程式呼叫的API，很多都是通過Binder機制呼叫到SystemServer程式中對應的服務上的。

在ZygoteInit的main函式中通過startSystemServer函式來啟動SystemServer程式。檢視startSystemServer方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //註釋1
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,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
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        //註釋3
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }
            //註釋5
            zygoteServer.closeServerSocket();
            //註釋4
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }
複製程式碼

這段程式碼在上面已經介紹過，最後通過handleSystemServerProcess方法啟動SystemServer程式，由於SystemServer是Zygote程式fork出來的，SystemServer程式也有一份Socket，但這個Socket對SystemServer程式沒有什麼用處，因此通過註釋5處關閉這個Socket。handleSystemServerProcess方法的程式碼如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws Zygote.MethodAndArgsCaller {

        ...
        if (systemServerClasspath != null) {
            ...
        } else {
            ...
            //註釋1
            ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        }

    }
複製程式碼

在註釋1處呼叫了ZygoteInit的zygoteInit方法，程式碼如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        ...
        //註釋1
        ZygoteInit.nativeZygoteInit();
        //註釋2
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

    private static final native void nativeZygoteInit();
複製程式碼

在註釋1處呼叫nativeZygoteInit方法來建立Binder執行緒池。註釋2處呼叫RuntimeInit的applicationInit方法，程式碼如下所示：

    //路徑：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
    protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        ...
        invokeStaticMain(args.startClass, args.startArgs, classLoader);
    }
複製程式碼

applicationInit方法中呼叫了invokeStaticMain方法，如下所示：

    //路徑：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
    private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        Class<?> cl;

        try {
            //註釋1
            cl = Class.forName(className, true, classLoader);
        } catch (ClassNotFoundException ex) {
            ...
        }

        Method m;
        try {
            //註釋2
            m = cl.getMethod("main", new Class[] { String[].class });
        } catch (NoSuchMethodException ex) {
           ...
        } catch (SecurityException ex) {
           ...
        }

        ...
        //註釋3
        throw new Zygote.MethodAndArgsCaller(m, argv);
    }
複製程式碼

在註釋1處通過反射獲取SystemServer類，這裡的className值是com.android.server.SystemServer，從前面ZygoteInit的startSystemServer方法中可以發現，程式碼如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //註釋1
        String args[] = {
            ...
            "com.android.server.SystemServer",
        };
        ...
        return true;
    }
複製程式碼

在傳入的引數中可以看到傳入的classname是com.android.server.SystemServer。

繼續回到invokeStaticMain方法中，在註釋2處獲取SystemServer的main方法，最後在註釋3處丟擲一個異常物件Zgote.MethodAndArgsCaller，使用這種方式是為了清理堆疊，這樣之後就會讓載入SystemServer類的main方法覺得自己是程式的入口。

接下來看ZygoteInit的main函式捕獲這個異常：

    //路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static void main(String argv[]) {
        ...
        try{
        } catch (Zygote.MethodAndArgsCaller caller) {
            //註釋1
            caller.run();
        } catch (Throwable ex) {
            ...
        }
        ...
    }
複製程式碼

註釋1處捕獲到Zygote.MethodAndArgsCaller異常後，呼叫它的run方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/Zygote.java
 public final class Zygote { 
    ...
    public static class MethodAndArgsCaller extends Exception
            implements Runnable {
        /** method to call */
        private final Method mMethod;

        /** argument array */
        private final String[] mArgs;

        public MethodAndArgsCaller(Method method, String[] args) {
            mMethod = method;
            mArgs = args;
        }

        public void run() {
            try {
                //註釋1
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (IllegalAccessException ex) {
                throw new RuntimeException(ex);
            } catch (InvocationTargetException ex) {
                Throwable cause = ex.getCause();
                if (cause instanceof RuntimeException) {
                    throw (RuntimeException) cause;
                } else if (cause instanceof Error) {
                    throw (Error) cause;
                }
                throw new RuntimeException(ex);
            }
        }
    }
}
複製程式碼

MethodAndArgsCaller中的成員變數mMethod，這裡指的就是SystemServer的main方法，在註釋1處通過反射執行SystemServer的main方法。

進入SystemServer的main方法中：

    //路徑：/frameworks/base/services/java/com/android/server/SystemServer.java
    public static void main(String[] args) {
        new SystemServer().run();
    }
複製程式碼

main方法中呼叫了SystemServer的run方法：

//路徑：/frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
        try {

            ...
            //建立訊息Looper
            Looper.prepareMainLooper();
            //載入動態庫libandroid_servers.so
            System.loadLibrary("android_servers");
            ...
            //建立系統的Context
            createSystemContext();
            //建立SystemServiceManager
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            //儲存SystemServiceManager
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
            //建立系統服務用的執行緒池
            SystemServerInitThreadPool.get();
        } finally {
            traceEnd();  // InitBeforeStartServices
        }

        //開啟服務
        try {
            traceBeginAndSlog("StartServices");
            //啟動引導服務
            startBootstrapServices();
            //啟動核心服務
            startCoreServices();
            //啟動其他服務
            startOtherServices();
            SystemServerInitThreadPool.shutdown();
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            traceEnd();
        }
        ...
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
複製程式碼

run方法中最重要的就是SystemServerManager，它的作用是用來對系統的服務進行建立、啟動和生命週期管理，建立完SystemServerManager物件後，在後面的三個啟動服務方法中會通過SystemServerManager來啟動服務，startBootstrapServices方法是用於啟動引導服務，引導服務包括ActivityManagerService、PowerManagerService、PackageManagerService、DeviceIdentifiersPolicyService等服務；startCoreServices方法用於啟動核心服務，核心服務包括DropBoxManagerService、BatteryService、UsageStatsService以及WebViewUpdateService；startOtherServices方法用於啟動其他服務，其他服務包括KeyChainSystemService、TelecomLoaderService、CameraService、AlarmManagerService等服務。

在啟動其他服務中會通過ActivityManagerService的systemReady方法來啟動Launcher。

---