梦幻曲：Android系统启动

之前花过一段时间整理了下Android系统启动、Activity启动以及ActivityThread等系统内容。时间久远，很多细节都忘了，本着互联共享的精神，在这里把之前的文档重新整理。计划写三篇文章：《梦幻曲：Android系统启动》，《沉思曲：Activity启动》、《小夜曲：ActivityThread分析》，一家之言难免有各种问题，仅供参考。
参考 | http://blog.csdn.net/jeffbao/article/details/18242515

概念

Dalvik虚拟机

当java程序运行时，都是有一个虚拟机来解释java的字节码，它将这些字节码翻译成本地CPU的指令码，然后执行。

AndroidRuntime

归纳起来的意思就是，Runtime 是支撑程序运行的基础库，它是与语言绑定在一起的。比如：

C Runtime：就是C standard lib，也就是我们常说的libc。（有意思的是， Wiki会自动将“C runtime" 重定向到 "C Standard Library")。
Java Runtime: 同样，Wiki将其重定向到” Java Virtual Machine"，这里当然包括Java 的支撑类库（.jar)。
AndroidRuntime: 显而易见，就是为Android应用运行所需的运行时环境。包括：
- Dalvik VM: Android的Java VM，解释运行Dex格式Java程序。每个进程运行一个虚拟机（什么叫运行虚拟机？说白了，就是一些C代码，不停的去解释Dex格式的二进制码(Bytecode)，把它们转成机器码(Machine code)，然后执行。
  - 当然，现在大多数的Java 虚拟机都支持JIT，也就是说，byte code可能在运行前就已经被转换成机器码，从而大大提高了性能。过去一个普遍的认识是Java 程序比C，C++等静态编译的语言慢，但随着JIT的介入和发展，这个已经完全是过去时了，JIT的动态性运行允许虚拟机根据运行时环境，优化机器码的生成，在某些情况下，Java甚至可以比C/C++跑得更快，同时又兼具平台无关的特性，这也是为什么Java如今如此流行的原因之一吧）。
- Android的Java 类库, 大部分来自于 Apache Hamony, 开源的Java API 实现，如 java.lang, java.util, java.net. 但去除了AWT, Swing 等部件。
- JNI: C和Java互调的接口。
- Libc: Android也有很多C代码，自然少不了libc，注意的是，Android的libc叫 bionic C.

图

框架图

在往下讲之前，先看下框架图：

框架图.png

代码流程图

Android系统启动流程图.png

init进程

init进程的启动配置在init.rc文件中，
note：init.rc文件的语法可参考：init.rc分析

1.1、init进程启动ServiceManager

/*service后第一个参数为进程名，第二个参数为进程路径，后面参数为启动改进程传递的参数*///service关键字启动servicemanagerservice servicemanager /system/bin/servicemanager    class core    user system    group system    critical    onrestart restart healthd    onrestart restart zygote    onrestart restart media    onrestart restart surfaceflinger    onrestart restart drm

Servicemanager负责管理所有的服务(native service、java service)，如服务的注册、查找等。
native service主要有： surfaceflinger、drm、media等。
java service主要有：ActivityManagerService、WindowManagerService、PowerManagerService等。
其中，native service大多在init.rc文件中由service关键字创建启动；java service大多由zygote创建启动。

1.2、init进程启动Zygote

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server    class main    socket zygote stream 660 root system    onrestart write /sys/android_power/request_state wake    onrestart write /sys/power/state on    onrestart restart media    onrestart restart netd

由service第二个参数可知，此处启动的进程为zygote进程，并由app_process实现。
zygote由java编写，不能有init进程直接启动；必须先生成Dalvik虚拟机，再在Dalvik虚拟机中装载zygote的实现类(ZygoteInit.java)。

Zygote进程

在往下讲Zygote进程前，先看附图，了解下Zygote都做啥了：

Zygote.png

Zygote进程的入口在app_main.cpp文件的main方法中，看下其main方法

2.1 main | app_main.cpp

int main(int argc, char* const argv[]){ ...  //解析入参，此处入参为“--zygote --start-system-server”  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);      set_process_name(niceName);  }  runtime.mParentDir = parentDir;  if (zygote) {      //start生成并初始化Dalvik虚拟机，并加载ZygoteInit类到虚拟机中      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;      //加载RuntimeInit类到虚拟机中      runtime.start("com.android.internal.os.RuntimeInit",              application ? "application" : "tool");  } else {      app_usage();      return 10;  }}

入参为“--zygote --start-system-server”，通过调用runtime.start创建和生成Dalvik虚拟机，并加载ZygoteInit类到虚拟机中。
加载ZygoteInit类，调用其main方法，启动SystemServer。

2.2、main | ZygoteInit.java

public static void main(String argv[]) {   try {      //注册server socket      //其它进程的创建,通过连接到该Socket后，由zygote孵化      registerZygoteSocket();      ...      //预加载android framework类和资源      preload();      ...      if (argv[1].equals("start-system-server")) {          //启动SystemServer          startSystemServer();      } else if (!argv[1].equals("")) {          throw new RuntimeException(argv[0] + USAGE_STRING);      }      //死循环接收client socket连接，由此创建新进程      runSelectLoop();      closeServerSocket();  } catch (MethodAndArgsCaller caller) {      caller.run();  } catch (RuntimeException ex) {      closeServerSocket();      throw ex;  }}

入参为"start-system-server"，Zygote进程调用 startSystemServer()方法启动SystemServer。

2.3、startSystemServer

startSystemServer方法在ZygoteInit.java中，看方法名是要启动SystemServer进程了。

private static boolean startSystemServer()        throws MethodAndArgsCaller, RuntimeException {   ...    //启动systemServer的参数    String args[] = {        "--setuid=1000",        "--setgid=1000",        "-- setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",        "--capabilities=" + capabilities + "," + capabilities,        "--runtime-init",        "--nice-name=system_server",        //启动的SystemServer全限定名，后续根据该参数反射创建实例        "com.android.server.SystemServer",    };    ZygoteConnection.Arguments parsedArgs = null;    int pid;    try {        /**         * 将传入参数进行转换         * 注意：参数com.android.server.SystemServer 放在parsedArgs中的remainingArgs里         */        parsedArgs = new ZygoteConnection.Arguments(args);        ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);        ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);        //Zygote为SystemServer创建子进程        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) {        handleSystemServerProcess(parsedArgs);    }    return true;}

Zygote为SystemServer创建新进程，并在新进程中调用handleSystemServerProcess。

SystemServer进程

上一步中调用了handleSystemServerProcess方法。

3.1、handleSystemServerProcess

该方法在ZygoteInit.java文件中

private static void handleSystemServerProcess(        ZygoteConnection.Arguments parsedArgs)        throws ZygoteInit.MethodAndArgsCaller {    //关闭SystemServer进程的serversocket    //SystemServer进程基础了父进程zygote所有资源    closeServerSocket();    //设置文件权限    Libcore.os.umask(S_IRWXG | S_IRWXO);    //设置新进程名    if (parsedArgs.niceName != null) {        Process.setArgV0(parsedArgs.niceName);    }    if (parsedArgs.invokeWith != null) {        WrapperInit.execApplication(parsedArgs.invokeWith,                parsedArgs.niceName, parsedArgs.targetSdkVersion,                null, parsedArgs.remainingArgs);    } else {        //remainArgs中包含SystemServer的全限定名：com.android.server.SystemServer             RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);    }}

新进程中接着调用RuntimeInit.zygoteInit方法

3.2、RuntimeInit.zygoteInit

RuntimeInit.zygoteInit为静态方法，在RuntimeInit.java文件中。

public static final void zygoteInit(int targetSdkVersion, String[] argv)        throws ZygoteInit.MethodAndArgsCaller {    if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");    redirectLogStreams();    commonInit();    nativeZygoteInit();    //调用该方法，往下执行    applicationInit(targetSdkVersion, argv);}

3.3、applicationInit

上方法接着调用了applicationInit方法，该方法在RuntimeInit.java文件中。

private static void applicationInit(int targetSdkVersion, String[] argv)        throws ZygoteInit.MethodAndArgsCaller {    //应用调用System.exit(),退出进程    nativeSetExitWithoutCleanup(true);    //设置堆    VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);    VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);    final Arguments args;    try {        args = new Arguments(argv);    } catch (IllegalArgumentException ex) {        Slog.e(TAG, ex.getMessage());        return;    }      //创建args.startClass实例，并调用其main方法    invokeStaticMain(args.startClass, args.startArgs);}

该方法接着调用invokeStaticMain方法，注意：此处args.startClass为com.android.server.SystemServer

3.4、invokeStaticMain

上方法接着调用了invokeStaticMain方法，该方同样在RuntimeInit.java中。看方法名，似乎是反射调用main方法。

private static void invokeStaticMain(String className, String[] argv)        throws ZygoteInit.MethodAndArgsCaller {    Class<?> cl;    try {        //全限定名，此处传入为"com.android.server.SystemServer"        cl = Class.forName(className);    }    ...    Method m;    try {        //main方法        m = cl.getMethod("main", new Class[] { String[].class });    }    ...    int modifiers = m.getModifiers();    if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {        throw new RuntimeException(                "Main method is not public and static on " + className);    }    /**     * 该异常会在ZygoteInit.main()中被捕获，     * 捕获后会触发MethodAndArgsCaller的run()方法，     * run方法中完成类main方法的调用     */    throw new ZygoteInit.MethodAndArgsCaller(m, argv);}

该方法最后通过抛异常的方式，抛出异常MethodAndArgsCaller；该异常被Zygote捕获，捕获后调用该异常的run方法，而在run放中完成类main方法的调用。
因此，该步最后调用SystemServer的main方法。

3.5、main | SystemServer.java

终于调用SystemServer的main方法了，看下其java层代码主要干啥了。

public static void main(String[] args) {    ...    //SystemServer需要一直运行，因此它需要有效的利用内存    VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);    Environment.setUserRequired(true);    System.loadLibrary("android_servers");       //初始化native服务    nativeInit();    //ServerThread并非Thread，它只是运行在SystemServer进程的主线程中    ServerThread thr = new ServerThread();    //调用该方法初始化和循环处理    thr.initAndLoop();}

3.6、initAndLoop

上面方法的主要内容在initAndLoop方法中，该方法是SystemServer的内部类ServerThread的方法。

public void initAndLoop() {    ...    //main looper    Looper.prepareMainLooper();    ...    try {        //启动DisplayManagerService服务，并注册到ServiceManager        display = new DisplayManagerService(context, wmHandler);        ServiceManager.addService(Context.DISPLAY_SERVICE, display, true);        //启动TelephonyRegistry服务，并注册到ServiceManager        telephonyRegistry = new TelephonyRegistry(context);        ServiceManager.addService("telephony.registry", telephonyRegistry);              //启动其它服务，并注册到ServiceManager        ...        //启动ActivityManagerService        ActivityManagerService.setSystemProcess();        //启动其它服务，并注册到ServiceManager        ...    //调用ActivityManagerService的systemReady方法，启动Launcher    ActivityManagerService.self().systemReady(new Runnable() {        public void run() {            ...             //开始系统启动画面            if (!headless) {                startSystemUi(contextF);            }           ...    });    //不停的从消息队列中获取消息    Looper.loop();}

initAndLoop方法中，SystemServer主要负责启动各种服务，并将启动的服务注册到ServiceManager中。
上方法中注意ActivityManagerService的启动，可知：
- AMS在SystemServier进程中运行；
- SystemServer调用AMS的systemReady方法来启动系统UI了;

插话

上面讲完SystemServer进程创建后，下一部分就是应用进程创建了，这部分内容在后面文章展开，这里贴副图简单描述下Zygote是如何创建应用进程的。改图以Zygote创建Launcher进程为例：

zygote创建应用进程.png

总结

回顾整篇内容，可以用下图做个简单描述：

总结.png

本文从init进程启动出发，沿着zygote进程、SystemServer进程创建流程分析了Android系统启动，其中内容无非是这么几点：

init进程创建了Zygote进程
Zygote进程孵化创建了SystemServer进程
SystemServer进程启动了Android常见的系统服务，如AMS、PMS等。及SystemServer可理解为应用与之交互的远程服务端。
已知Android的每个进程都与一个VM关联，上面代码未展开描述，但可概括为：VM由Zygote创建，Zygote每创建一个进程，就为为该进程拷贝一份VM实例，从而实现关联。

在后面的两篇文章中，会从Activity启动角度出发，分析Zygote是如何创建应用进程，以及ActivityThread有如何使主线程等问题。

概念