Android进阶知识树——Android系统的启动过程

1、init进程

作为Android开发者和Android使用者，相信每个人都接触过多种Android设备，不管是哪种品牌、哪种类型的Android设置，在使用之前都要完成开机操作，对于普通用户来说开机只是一个操作过程，但对于开发者有没有想过Android是如何开机的？是如何从断电状态启动到可操作交互的？开发者都听过init进程、孵化器进程已经开发中使用的各种服务，那么它们又是如何启动如何工作的呢？带着这些问题进入本篇文章的主题Androdi系统的启动过程；

Android系统的启动过程总结

启动电源：按下电源后，程序从固定地方开始加载引导程序到RAM中
引导程序BootLoader：Android系统开始执行引导程序，并同时拉起并运行系统的OS
Linux内核启动：当内核启动完成后，首先寻找init.rc配置文件并启动init进程
init进程启动：在init进程中完成属性服务的初始、Zygote进程的启动

由上面的程序启动过程知道，程序在执行完引导程序并启动内核后，首先会查找init文件，在init文件中首先执行main（）方法

init.main（）

......property_init();//1......sigchld_handler_init();//2......start_property_service();......LoadBootScripts(am, sm);static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {    Parser parser = CreateParser(action_manager, service_list);    parser.ParseConfig("/init.rc"); //3}

在main（）函数中主要执行一下操作：

初始化和启动属性服务
设置进程信号处理
解析init.rc配置文件

1.1、属性服务初始化与启动

属性服务的初始化

创建非阻塞的Socket
调用listen函数对对属性进行监听
当有数据更新时，init进程会调用handle_property_set_fd函数进行处理

处理客户端请求

服务属性接收到客户端请求时调用handle_property_set_fd（）处理数据
根据属性分类处理：普通属性、控制属性

1.2、设置进程信号处理

僵尸进程：父进程通过Fork创建子进程，当子进程终止之后，如果父进程不知道此时子进程已结束，此时系统中会仍然保存着进程的信息，那么子进程就会成为僵尸进程

僵尸进程危害：系统资源有限，僵尸进程会占用系统资源，当资源耗尽时系统将无法创建新的进程

由僵尸进程的定义知道，出现僵尸进程的原因就是父进程与子进程之间通信中断，signal_handler_init函数就是在父进程中监听子进程的状态，在子进程暂停或终止时会发送SIGCHLD信号，signal_handler_init会接收和处理信号，当接收到子进程终止时及时的释放资源

1.3、解析init配置文件

配置文件的解析和处理也是init进程中最主要的部分，安卓中将系统的配置文件保存在init.rc文件中，而Android 8.0之后对init.rc文件浸信会拆分，将每个服务以启动脚本的形式单独存在，然后在init.rc中引入所需要的服务脚本，在启动的时候就可以实现所有服务的启动，这里以接下来要分析的Zygote的启动脚本为例，看看系统是如何定义和处理脚本的

启动脚本——init.zygote64.rc

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server    class main    priority -20    user root    group root readproc reserved_disk    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：创建的进程名称
/system/bin/app_process64 ：执行的文件路径
class main：表示Zygote的classname为main，后面会根据main查找Zygote服务
onrestart：当进程启动时需要重启的服务

上面启动脚本文件的名称为nit.zygote64.rc，脚本文件名称表示只支持64系统，不过有的启动过脚本会同时支持32为和64为系统，如init.zygote64_32.rc

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote    class main      ......    writepid /dev/cpuset/foreground/tasksservice zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary --enable-lazy-preload    class main      .......    writepid /dev/cpuset/foreground/tasks

init.zygote64_32.rc脚本文件中有有两个Zygote服务，一个主模式支持64位的名为zygote进程，另一个辅模式支持32为名为zygote_secondary进程，系统会根据设备的属性决定启动的服务；

解析启动脚本

init进程中会使用ServerParse对Service的启动脚本进行解析，最终会针对启动脚本中的每个服务创建对应的实例，然后将所有的对象实例缓存在Service裢表中，在启动服务时就会从此列表中查找对应的服务对象；

2、Zygote进程启动

在init.rc文件中引入Zygote的启动脚本，所以在解析init.rc配置文件的服务时，就会将Zygote启动脚本中的服务解析保存在Service的裢表中

import /init.${ro.zygote}.rc

init启动Zygote进程

on nonencrypted    class_start main    class_start late_start

在解析服务后，会继续init.rc配置文件中的程序，程序执行class_start main，由前面的服务脚本可知classnam为main代表的时Zygote服务，所以此处代表启动Zygote进程，首先会遍历前面保存解析Service的链表，查找classname为main（）的服务，然后执行Service中的start（）方法；

Result<Success> Service::Start() {pid_t pid = -1;    if (namespace_flags_) {        pid = clone(nullptr, nullptr, namespace_flags_ | SIGCHLD, nullptr);    } else {        pid = fork(); //1、    }    if (pid == 0) { //2、    if (!ExpandArgsAndExecv(args_)) {            PLOG(ERROR) << "cannot execve('" << args_[0] << "')";        }    }}static bool ExpandArgsAndExecv(const std::vector<std::string>& args) {    return execv(c_strings[0], c_strings.data()) == 0; //3、}

在statr（）方法中，首先判断进程是否已经运行，对未运行的进程通过fork（）创建子进程，创建成功后调用ExpandArgsAndExecv（）方法，在ExpandArgsAndExecv（）中调用执行execv（）后Service进程就被启动并进入Service的main（）方法，Zygote进程对应的程序路径为app_main.cpp,在app_main.cpp的main（）方法中调用runtime.start()启动进程

int main(int argc, char* const argv[]){        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;       }    }}if (zygote) {       runtime.start("com.android.internal.os.ZygoteInit", args, zygote);   }

在app_main文件的main（）方法中，首先根据进程的名称判断当前是否为Zyote进程，并赋值zygote为true，然后调用runtime.start（）启动进程，注意这里的参数传入的是ZygoteInit类的全路径，这里先猜测下最后是根据全路径反射执行ZygoteInit方法，接着看runtime，这里的runtime指的是AndroidRuntime

AndroidRuntime.start（）

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) { //1        return;    }    onVmCreated(env);    if (startReg(env) < 0) { // 2        return;    }char* slashClassName = toSlashClassName(className != NULL ? className : "");//3jclass startClass = env->FindClass(slashClassName);// 4jmethodID startMeth = env->GetStaticMethodID(startClass, "main",            "([Ljava/lang/String;)V"); // 5   if (startMeth == NULL) {            ALOGE("JavaVM unable to find main() in '%s'\n", className);   } else {         env->CallStaticVoidMethod(startClass, startMeth, strArray); //6         if (env->ExceptionCheck())            threadExitUncaughtException(env);     }}

在AndroidRuntime的start()方法中，执行了Zygote进程的主要逻辑：

启动Java虚拟机
为Java虚拟机注册JNI方法
通过JNI调用Java层ZygoteInit类中的方法完成进程的启动，此时程序由native进入Java层

ZygoteInit

public static void main(String argv[]) {   ZygoteServer zygoteServer = new ZygoteServer();//1   zygoteServer.registerServerSocketFromEnv(socketName);   preload(bootTimingsTraceLog);//2    if (startSystemServer) {     Runnable r = forkSystemServer(abiList, socketName, zygoteServer);//3     if (r != null) {                    r.run();                    return;               }            }   caller = zygoteServer.runSelectLoop(abiList); //4}

程序进入Java层执行ZygoteInit.main（）方法，在main（）中主要执行：

首先创建并注册Service端的Socket
预加载类和资源
调用forkSystemServer（）启动SystemServer进程
执行zygoteServer.runSelectLoop（）循环等待AMS请求创建新的应用进程

关于ZygoteServer的注册和循环等待AMS创建进程的部分之后在AMS启动中介绍，这里先来看看startSystemServer（）启动SystemServer进程部分；

4、SystemServer启动过程

SystemServer进程主要用于创建系统服务，如：AMS、WMS、PMS等，由上面知道系统会调用startSystemServer（）

private static Runnable forkSystemServer(String abiList, String socketName,       ZygoteServer zygoteServer) {      String args[] = { //1            "--setuid=1000",            "--setgid=1000",            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1024,1032,1065,3001,3002,3003,3006,3007,3009,3010",            "--capabilities=" + capabilities + "," + capabilities,            "--nice-name=system_server",            "--runtime-args",            "--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,            "com.android.server.SystemServer",        };           parsedArgs = new ZygoteConnection.Arguments(args);  //2        pid = Zygote.forkSystemServer(  //3                    parsedArgs.uid, parsedArgs.gid,                    parsedArgs.gids,                    parsedArgs.runtimeFlags,                    null,                    parsedArgs.permittedCapabilities,                    parsedArgs.effectiveCapabilities); }      if (pid == 0) {             return handleSystemServerProcess(parsedArgs);//4        }

在forkSystemServer（）方法中首先将启动参数封装在数组中，然后使用数组创建ZygoteConnection.Arguments对象，最后调用Zygote.forkSystemServer方法fok SystemServer进程，fork进程成功后调用handleSystemServerProcess（）处理进程中的工作；

private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {            ClassLoader cl = null;            if (systemServerClasspath != null) {               cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);               Thread.currentThread().setContextClassLoader(cl);            }            return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);    }

在handleSystemServerProcess（）中首先创建PathClassLoader对象，然后调用ZygoteInit.zygoteInit（）方法

ZygoteInit.zygoteInit

 public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {        ZygoteInit.nativeZygoteInit(); //1、        return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);//2、}

在zygoteInit（）中调用nativeZygoteInit（）方法，从名字上看出调用的是native方法，在内部通过JNI方法完成Binder线程池的创建，在方法的最后调用RuntimeInit.applicationInit（）方法传入ClassLoader，applicationInit（）方法相对比较特殊，下面一起看下源码

protected static Runnable applicationInit(int targetSdkVersion, String[] argv,            ClassLoader classLoader) {        final Arguments args = new Arguments(argv);        return findStaticMain(args.startClass, args.startArgs, classLoader);//1    } protected static Runnable findStaticMain(String className, String[] argv,            ClassLoader classLoader) {        Class<?> cl;        try {            cl = Class.forName(className, true, classLoader);//2        } catch (ClassNotFoundException ex) {            throw new RuntimeException(                    "Missing class when invoking static main " + className,                    ex);        }        Method m;        try {            m = cl.getMethod("main", new Class[] { String[].class });//3        } catch (NoSuchMethodException ex) {            throw new RuntimeException(                    "Missing static main on " + className, ex);        } catch (SecurityException ex) {            throw new RuntimeException(                    "Problem getting static main on " + className, ex);        }        int modifiers = m.getModifiers();        if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {           throw new RuntimeException(                    "Main method is not public and static on " + className);        }        return new MethodAndArgsCaller(m, argv); //4    }

applicationInit（）中调用了findStaticMain（）方法，findStaticMain（）并没有直接调用SystemServer.main（）方法，而是通过反射获取SystemServer的Class，然后获取main（）方法，并将main方法和参数封装在MethodAndArgsCaller中，这一点Android P中做了修改，之前的版本中将反射main方法封装在异常中抛出，然后捕捉异常执行，Android P返回了MethodAndArgsCaller对象，MethodAndArgsCaller继承实现Runnable，其实在前面ZygoteInit类中，有一段代码如下

if (startSystemServer) {                Runnable r = forkSystemServer(abiList, socketName, zygoteServer);                if (r != null) {                    r.run();                    return;                }            }

整个SystemServer继承的启动是从调用forkSystemServer（）开始的，forkSystemServer返回了Runnable对象，这里的Runnable对象就是上面创建的MethodAndArgsCaller对象，然后调用run（）方法执行MethodAndArgsCaller对象；

static class MethodAndArgsCaller implements Runnable {        private final Method mMethod;        private final String[] mArgs;        public MethodAndArgsCaller(Method method, String[] args) {            mMethod = method;            mArgs = args;        }        public void run() {            try {                mMethod.invoke(null, new Object[] { mArgs });            } catch (IllegalAccessException ex) {        }    }

在MethodAndArgsCaller中保存了反射获取的Method，这里的Method就是SystemServer.main（）方法，在run方法中调用method.invoke（）执行main方法，反射执行之后程序进入SystemServer.main（）,main中创建SystemServer对象，并执行run（）方法；

public static void main(String[] args) {        new SystemServer().run();    }

SystemServer.run（）

mSystemServiceManager = new SystemServiceManager(mSystemContext); //1// Start services.        try {            startBootstrapServices();//2            startCoreServices();//3            startOtherServices();//4            SystemServerInitThreadPool.shutdown();        } catch (Throwable ex) {            throw ex;        }

main方法中直接调用SystemServer.run（）方法，在run（）方法中，首先创建系统的SystemServiceManager对象，然后依次调用方法启动引导服务、启动核心服务、启动其他服务

启动服务过程

mSystemServiceManager.startService(PowerManagerService.class);  public SystemService startService(String className) {        final Class<SystemService> serviceClass;        try {            serviceClass = (Class<SystemService>)Class.forName(className);        } catch (ClassNotFoundException ex) {        }        return startService(serviceClass);    }

系统调用SystemServerManager.startService（）传入对应的服务，在startService（）中根据传入的类名加载类文件，然后执行startService(serviceClass)方法，startService中使用加载的Class获取构造函数并创建对象，然后调用startService(service)；

Constructor<T> constructor = serviceClass.getConstructor(Context.class);service = constructor.newInstance(mContext);public void startService(@NonNull final SystemService service) {        mServices.add(service); //1        try {            service.onStart();//2        } catch (RuntimeException ex) {    }

在startService（）中，先将service注册到mServices中，然后调用service.onStart（）方法启动服务；

到此Android系统的启动过程及Zygote的启动过程就介绍完毕了！