Android进阶之App启动流程和源码详解

作者：Android开发编程 2021-08-10 20:41:33移动开发 Android Android中有四大组件：Activity、进阶Service、动流BroadcastReceiver、程和ContentProvider。源码我们最常接触也是详解用户直接感受到的就是Activity了，今天来就说说Android启动的进阶执行过程和工作原理。

本文转载自微信公众号「Android开发编程」，动流作者Android开发编程。程和转载本文请联系Android开发编程公众号。源码

前言

Android中有四大组件：Activity、详解Service、进阶BroadcastReceiver、动流ContentProvider。程和我们最常接触也是源码用户直接感受到的就是Activity了，今天来就说说Android启动的详解执行过程和工作原理。

Activity是一种 展示型组件，用于展示给用户一个可以交互的页面。Activity是Android中最重要的组件，对用户来说，所有的Activity就是一个App的全部，而其他组件用户是不能直接感知的;

今天我们就来分析总结下app启动流程的场景和知识点

一、启动中设计到关键类详解

1、启动流程设计到主要类

• ActivityManagerServices，简称AMS，服务端对象，负责系统中所有Activity的生命周期;
• ActivityThread，App的真正入口。当开启App之后，会调用main()开始运行，开启消息循环队列，这就是传说中的UI线程或者叫主线程。与ActivityManagerServices配合，一起完成Activity的管理工作;
• ApplicationThread，用来实现ActivityManagerService与ActivityThread之间的交互。在ActivityManagerService需要管理相关Application中的Activity的生命周期时，通过ApplicationThread的代理对象与ActivityThread通讯;
• ApplicationThreadProxy，是ApplicationThread在服务器端的代理，负责和客户端的ApplicationThread通讯。AMS就是通过该代理与ActivityThread进行通信的;
• Instrumentation，每一个应用程序只有一个Instrumentation对象，每个Activity内都有一个对该对象的引用。Instrumentation可以理解为应用进程的管家，ActivityThread要创建或暂停某个Activity时，都需要通过Instrumentation来进行具体的操作;
• ActivityStack，Activity在AMS的栈管理，用来记录已经启动的Activity的先后关系，状态信息等。通过ActivityStack决定是否需要启动新的进程;
• ActivityRecord，ActivityStack的管理对象，每个Activity在AMS对应一个ActivityRecord，来记录Activity的状态以及其他的管理信息。其实就是服务器端的Activity对象的映像;
• TaskRecord，AMS抽象出来的一个“任务”的概念，是记录ActivityRecord的栈，一个“Task”包含若干个ActivityRecord。AMS用TaskRecord确保Activity启动和退出的顺序。如果你清楚Activity的4种launchMode，那么对这个概念应该不陌生;
• 可以说，启动的流程就是通过这几个类之间不断通信的过程;

2、zygote

• zygote意为“受精卵“。Android是基于Linux系统的，而在Linux中，所有的进程都是由init进程直接或者是间接fork出来的，zygote进程也不例外。
• 在Android系统里面，zygote是一个进程的名字。Android是基于Linux System的，当你的手机开机的时候，Linux的内核加载完成之后就会启动一个叫“init“的进程。在Linux System里面，所有的进程都是由init进程fork出来的，我们的zygote进程也不例外。
• 我们都知道，每一个App其实都是:一个单独的dalvik虚拟机
• 一个单独的进程;
• 所以当系统里面的第一个zygote进程运行之后，在这之后再开启App，就相当于开启一个新的进程。而为了实现资源共用和更快的启动速度，Android系统开启新进程的方式，是通过fork第一个zygote进程实现的。所以说，除了第一个zygote进程，其他应用所在的进程都是zygote的子进程;

3、SystemServer

SystemServer也是一个进程，而且是由zygote进程fork出来的

在zygote开启的时候，会调用ZygoteInit.main()进行初始化

public static void main(String argv[]) {  
     ...ignore some code... 
    //在加载首个zygote的时候，会传入初始化参数，使得startSystemServer = true 
     boolean startSystemServer = false; 
     for (int i = 1; i < argv.length; i++) {  
                if ("start-system-server".equals(argv[i])) {  
                    startSystemServer = true; 
                } else if (argv[i].startsWith(ABI_LIST_ARG)) {  
                    abiList = argv[i].substring(ABI_LIST_ARG.length()); 
                } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {  
                    socketName = argv[i].substring(SOCKET_NAME_ARG.length()); 
                } else {  
                    throw new RuntimeException("Unknown command line argument: " + argv[i]); 
                } 
            } 
            ...ignore some code... 
         //开始fork我们的SystemServer进程 
     if (startSystemServer) {  
                startSystemServer(abiList, socketName); 
         } 
     ...ignore some code... 
} 

startSystemServer()做了些什么

/**留着这个注释，就是为了说明SystemServer确实是被fork出来的 
     * Prepare the arguments and fork for the system server process. 
     */ 
    private static boolean startSystemServer(String abiList, String socketName) 
            throws MethodAndArgsCaller, RuntimeException {  
         ...ignore some code... 
        //留着这段注释，就是为了说明上面ZygoteInit.main(String argv[])里面的argv就是通过这种方式传递进来的 
        /* Hardcoded command line to start the system server */ 
        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", 
            "com.android.server.SystemServer", 
        }; 
        int pid; 
        try {  
            parsedArgs = new ZygoteConnection.Arguments(args); 
            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs); 
            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs); 
        //fork出来的 -_-||| 
            /* Request to fork the system server process */ 
            pid = Zygote.forkSystemServer( 
                    parsedArgs.uid, parsedArgs.gid, 
                    parsedArgs.gids, 
                    parsedArgs.debugFlags, 
                    null, 
                    parsedArgs.permittedCapabilities, 
                    parsedArgs.effectiveCapabilities); 
        } catch (IllegalArgumentException ex) {  
            throw new RuntimeException(ex); 
        } 
        /* For child process */ 
        if (pid == 0) {  
            if (hasSecondZygote(abiList)) {  
                waitForSecondaryZygote(socketName); 
            } 
            handleSystemServerProcess(parsedArgs); 
        } 
        return true; 
    } 

4、ActivityManagerService

• ActivityManagerService，简称AMS，服务端对象，负责系统中所有Activity的生命周期。
• ActivityManagerService进行初始化的时机很明确，就是在SystemServer进程开启的时候，就会初始化ActivityManagerService。

public final class SystemServer {  
    //zygote的主入口 
    public static void main(String[] args) {  
        new SystemServer().run(); 
    } 
    public SystemServer() {  
        // Check for factory test mode. 
        mFactoryTestMode = FactoryTest.getMode(); 
    } 
    private void run() {  
        ...ignore some code... 
        //加载本地系统服务库，并进行初始化  
        System.loadLibrary("android_servers"); 
        nativeInit(); 
        // 创建系统上下文 
        createSystemContext(); 
        //初始化SystemServiceManager对象，下面的系统服务开启都需要调用SystemServiceManager.startService(Class<T>)，这个方法通过反射来启动对应的服务 
        mSystemServiceManager = new SystemServiceManager(mSystemContext); 
        //开启服务 
        try {  
            startBootstrapServices(); 
            startCoreServices(); 
            startOtherServices(); 
        } catch (Throwable ex) {  
            Slog.e("System", "
(责任编辑：综合)