一、关于Android系统重要的进程

（1）、init进程：init进程是Linux内核启动完成之后，启动的第一个用户进程，Android系统就是在这个进程的基础上启动起来的，进程pid为1。init进程通过解析init.rc来陆续启动其他关键的系统服务进程---其中最重要的是：ServiceManager，Zygote和SystemServer。

（2）、ServiceManager：主要负责添加服务，获取服务，查找服务以及当某个服务意外终止时，对该服务的资源进行回收。
（3）、Zygote进程：Zygote是一个孵化器进程，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程fork出来的。在Zygote中进行添加虚拟机参数，并将其启动起来，然后注册JNI函数。在Zygote中进行预加载以及初始化核心类库。最后将SystemServer启动起来。
（4）、SystemServer：启动系统各项服务。

二、init.rc脚本语法规则

service <name> <pathname> [ <argument> ]*   //service的名字,启动路径,以及参数
   <option>      
   <option>
    ...

<name>:
表示此service的名称
<pathname>:
此service所在的路径。因为是可执行文件，所以一定有存储路径。
<argument>:
启动service所带的参数。
<option>:
对此service的约束选项。

三、ServiceManager，Zygote，SystemServer的启动简析

3.1 ServiceManager

       ServiceManager是Binder机制中的“DNS服务器”，负责域名(某Binder服务在ServiceManager注册时提供的名称)IP地址（由底层Binder驱动分配的值）的解析。
       ServiceManager是在servicemanager.rc(Android8.0)里面描述，并由init进程启动。

service servicemanager /system/bin/servicemanager
    class core animation
    user system
    group system readproc
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart audioserver
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart inputflinger
    onrestart restart drm
    onrestart restart cameraserver
    writepid /dev/cpuset/system-background/tasks

       可以看到，Servicemanager是一个Linux程序。它在设备中的存储路径是：/system/bin/servicemanager，源码路径则是：
android-8.0.0_r1\frameworks\native\cmds\servicemanager\servicemanager.c

      ServiceManager所属的class是core,其他同类的系统进程包括ueventd，console(/system/bin/sh)，adbd等。根据core组的特性，这些进程会同时被启动或停止。另外，critical选项说明它是系统的关键进程---意味着如果进程不幸在4分钟内异常退出超过4次，则设备将重启并进入还原模式。当ServiceManager每次重启是，其他关键进程如zygote，media，surfaceflinger等也会被restart。

3.2 Zygote

       在Android系统中，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育（fork）出来的，因为Android系统是基于Linux内核的，而在Linux系统中，所有的进程都是init进程的子孙进程，也就是说，所有的进程都是直接或者间接地由init进程fork出来的。Zygote进程也不例外，它是在系统启动的过程，由init进程创建的，在系统启动脚本android-8.0.0_r1\system\core\rootdir\init.*.rc文件中，我们可以看到启动Zygote进程的脚本命令：

例如：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

从上面这段脚本描述可以看出：
ServiceName:zygote
Path:/system/bin/app_process
Arguments:-Xzygote /system/bin --zygote --start-system-server

       Zygote所属class为main，而不是core。和其同class的系统进程有netd，debuggerd，rild等。从zygote的path可以看出，它所在的应用程序名叫"app_process"。通过指定--zygote参数，app_process可以识别出用户是否需要启动zygote。
"app_process"程序源码路径在：android-8.0.0_r1\frameworks\base\cmds\app_process\app_main.cpp中。

app_process_path.png

android-8.0.0_r1\frameworks\base\cmds\app_process\Android.mk主要内容：

LOCAL_SRC_FILES:= \
    app_main.cpp

LOCAL_LDFLAGS := -Wl,--version-script,art/sigchainlib/version-script.txt -Wl,--export-dynamic

LOCAL_SHARED_LIBRARIES := \
    libdl \
    libcutils \
    libutils \
    liblog \
    libbinder \
    libnativeloader \
    libandroid_runtime \
    $(app_process_common_shared_libs) \

LOCAL_WHOLE_STATIC_LIBRARIES := libsigchain

LOCAL_MODULE:= app_process

"app_process"的源码路径在:
android-8.0.0_r1\frameworks\base\cmds\app_process\app_main.cpp
其主要函数：

int main(int argc, char* const argv[])
{
    ...
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));

    // After the parent dir, we expect one or more the following internal
    // arguments :
    //
    // --zygote : Start in zygote mode
    // --start-system-server : Start the system server.
    // --application : Start in application (stand alone, non zygote) mode.
    // --nice-name : The nice name for this process.


    // 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;
        }
    }

    Vector<String8> args;
    if (!className.isEmpty()) {
        // We're not in zygote mode, the only argument we need to pass
        // to RuntimeInit is the application argument.
        //
        // The Remainder of args get passed to startup class main(). Make
        // copies of them before we overwrite them with the process name.
        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"));
        }

        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);

        // In zygote mode, pass all remaining arguments to the zygote
        // main() method.
        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);
    } 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;
    }
}

因为，在此init.rc指定了--zygote选项，因而app_process接下来将启动"ZygoteInit"并传入"start-system-server"。
AppRuntime 继承自AndroidRuntime，所以,runtime.start()函数对应源码：
android-8.0.0_r1\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);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {//启动虚拟机
        return;
    }
    onVmCreated(env);//虚拟机启动后的回调

    
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

...

}

除了与装载各种系统类(具体实现在ZygoteInit#preload()这个方法里)外，ZygoteInit的另一个重要工作就是启动SystemServer---这是大部分Android系统服务(由Java语言编写)的所在地。

3.3 SystemServer(Android的系统服务)

       SystemServer是Android进入Laucher前的最后准备。
       一旦在init.rc中为zygote指定了启动参数--start-system-server，那么ZygoteInit就会调用startSystemServer来启动SystemServer。

    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
       ...
        
        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);
            ...
            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);
            }

            zygoteServer.closeServerSocket();
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }

       根据fork的特性，子进程和父进程将获得同样的代码环境。当变量pid值为0时，说明是子进程，否则是父进程；如果是前者的话，则进一步调用handleSystemServerProcess来完成剩下的工作，也是最核心的部分---启动各种系统服务。并在一切准备就绪后进入Launcher主界面。