Android攻城狮Android知识Android技术知识

梦幻曲：Android系统启动

2017-06-17  本文已影响92人  空同定翁

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

概念

Dalvik虚拟机

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

AndroidRuntime

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

图

框架图

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

框架图.png

代码流程图

Android系统启动流程图.png

init进程

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

1.1、init进程启动ServiceManager

/*service后第一个参数为进程名，第二个参数为进程路径，后面参数为启动改进程传递的参数*/

//service关键字启动servicemanager
service 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

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

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

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

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

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

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

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

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

插话

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


zygote创建应用进程.png

总结

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

总结.png

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

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

上一篇 下一篇

猜你喜欢

热点阅读