Android从开机到APP启动流程——基于Android9.0_进程的启动流程

Android从开机到APP启动流程——基于Android9.0

一、 Zygote进程启动流程
二、 System Server启动流程
三、 ActivityManagerService启动流程
四、 Launcher App (Home Activity)启动流程
五、 Zygote fork()子进程，子进程入口为ActivityThread.main()
六、 Activity的启动流程（从ActivityThread到Activity）

从开机到APP启动流程宏观流程

一、 Zygote进程启动流程

Zygote进程是所有应用程序的鼻祖。 SystemServer以及其他所有 Dalivik虚拟机进程都是由 Zygote进程通过调用系统函数fork()而来。

Zygote 由 app_process 启动，app_process 映射为 app_main.cpp。

Zygote进程在 Android中属于C/S模型，Zygote进程作为 Server服务端，接收其它进程作为客户端向它发出的 “fork” 请求。Zygote进程接收到这个请求后，就调用系统函数fork()孵化出一个新的进程。所有由 fork创建的应用程序进程和 SystemServer进程都将获得一个 JVM实例拷贝。

fork()函数调用一次，将会返回两次。

两次返回分别属于原进程和新进程。

fork()采用copy-on-write机制，有些累如果不做改变，甚至都不用复制，子进程和父进程可以共享这部分数据，从而省去不少内存的占用（图片来自gityuan）

0. Zygote启动流程图

从开机到 Zygote进程启动，途径了内核态与用户态，在用户态中，从 native层调用到了 Java层。最后在AndroidRuntime.cpp # strat()注册 JNI方法完成后，通过反射调用ZygoteInit.java # main() 正式地进入到 Zygote进程。

1. 执行init.rc文件

Linux内核启动后，通过解析 init.rc文件，会启动 Zygote相关的服务，从而启动 Zygote进程。

在/system/core/rootdir目录中有四个 zygote相关的服务脚本。

其中 init.zygote64.rc 支持64位的zygote，其 Android初始化语言为：

service zygote /system/bin/app_process64 -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
 writepid /dev/cpuset/foreground/tasks
1
2
3
4
5
6
7
8

其中 /system/bin/app_process64 映射的执行文件为 /frameworks/base/cmds/app_process/app_main.cpp

2. app_main.cpp # main()

说明

app_main.cpp 的任务是根据 zygote的脚本的参数进行解析，在解析到有 --zygote 字符后，决定执行 AndroidRuntime.cpp#start()方法。
最后来到ZygoteInit.java方法中，发起Zygote启动

源码

public static void main(String argv[]) {
      //创建ZygoteServer
      ZygoteServer zygoteServer = new ZygoteServer();
      //...
      //用于fork()后的进程执行最后的通过反射执行的main()方法
      final Runnable caller;
     
      //register handlers for DDM(Dalvik Debug Monitor) messages
      //用于debug的handler
      RuntimeInit.enableDdms();
    
      //配置，如是否打开SystemServer，socketName是什么，是否开启LazyPreload等

      // 注册Server端的Socket，用于接收消息
      zygoteServer.registerServerSocketFromEnv(socketName);
      
      if (!enableLazyPreload) {
        // 预加载类和资源
        preload(bootTimingsTraceLog);
      } 

      //开启gc
      gcAndFinalize();

      if (startSystemServer) {
        // fork一个SystemServer进程
        Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
        if (r != null) {
          //fork出来的System Server的r不为空，会进入该方法
          //通过执行run()进入System Server的main()方法
          r.run();
          return;
        }
      }
      // 等待AMS请求
      caller = zygoteServer.runSelectLoop(abiList);
      //最后关闭socket
      zygoteServer.closeServerSocket();
    }
    if (caller != null) {
      //fork出来的App进程将会进入该方法
      //通过执行run()进入ActivityThread的main()方法
      caller.run();
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

二、 System Server启动流程

Zygote是所有应用的鼻祖。SystemServer和其他应用进程都是由 Zygote通过“孵化 fork”而来。``ZygoteInit.java#main()`` 中第一个 fork的进程就是 SystemServer，在手机中其进程名为 system_server。

system_server 进程承载着整个 framework层的核心服务，例如创建 AMS（ActivityManagerService）。PKMS（PackageManagerService）等。这些服务以不同的线程方式存在于 system_server这个进程中。
1
2
3

0. SystemServer 启动流程图

SystemServer进程由 Zygote进程通过系统函数fork()而来，它管理着整个 framework层，在打开Looper循环接收消息前，做好一切准备工作，并且启动引导服务、核心服务、其他各种服务。 SystemService是一个进程，所有的 Service服务都以线程的方式运行在其中。

1. ZygoteInit.java # main()

说明

ZygoteInit.java # main()是 Zygote进程的入口，它的主要任务是启动 SystemServer以及开启循环接受 socket传来的创建子进程的消息。

SystemServer进程的创建，需要在 Zygote进程中，通过ZygoteInit.java # forkSystemServer()来孵化一个 SystemServer进程。孵化出来的 SystemServer进程与 Zygote进程运行到if(r!=null)的执行过程是不同的。SystemServer将会进入判断体，通过r.run()来执行SystemServer.java # main(),而 Zygote进程将会跳出判断体，继续执行后续代码。

源码

public static void main(String argv[]){
    //...
    if (startSystemServer) {
        // fork一个SystemServer进程出来
        Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
        if (r != null) {
          //fork出来的System Server进行到这里，r不为null
          //r.run将会执行SystemServer.java#main()
          r.run();
          return;
        }
      }
    //Zygote进程将会跳出if，继续运行后续代码
    //...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. ZygoteInit.java # forkSystemServer()

说明

ZygoteInit.java#main() 中通过 ZygoteInit.java#forkSystemServer() 方法孵化出一个 SystemServer进程。在这个方法内，通过 Zygote.java#forkSystemServer() 的Zygote.java#nativeForkSystemServer() 来真正孵化一个 SystemServer进程出来。

源码

private static Runnable forkSystemServer(String abiList, String socketName,
      ZygoteServer zygoteServer) {
   
    try {
      //...
      /* Request to fork the system server process */
      //通过 Zygote.forkSystemServer的native方法来fork一个System Server进程出来。
      pid = Zygote.forkSystemServer(
          parsedArgs.uid, parsedArgs.gid,
          parsedArgs.gids,
          parsedArgs.runtimeFlags,
          null,
          parsedArgs.permittedCapabilities,
          parsedArgs.effectiveCapabilities);
    } catch (IllegalArgumentException ex) {
      throw new RuntimeException(ex);
    }

    //pid=0表示fork成功，子进程正在执行
    //pid=-1fork失败
    //pid>0返回的是子进程的实际pid，表示父进程正在执行
    /* For child process */
    if (pid == 0) {
      //pid==0说明fork成功，进入该方法，当前是 System Server进程
      if (hasSecondZygote(abiList)) {
        waitForSecondaryZygote(socketName);
      }
	  //接下去就是SystemServer进程，不再需要socket通信
      zygoteServer.closeServerSocket();
      //处理System Server后续的执行内容。
      //通过反射把SystemServer.java的main()方法暴露出去使用
      return handleSystemServerProcess(parsedArgs);
    }
	//pid!=0说明当前是Zygote进程，返回null，ZygoteInit.main()将会继续往下执行。
    return null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

3. ZygoteInit.java # handleSystemServerProcess()

说明

运行到这个方法，说明该段代码运行在由 Zygote孵化出来的 SystemServer进程中，该方法的任务主要是对 dex进行优化操作，并且通过ZygoteInit.java#zygoteInit()方法使用反射包装将SystemServer.java#main()方法暴露出去

源码

private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
    if (systemServerClasspath != null) {
      //进行dex优化操作
      performSystemServerDexOpt(systemServerClasspath);
      //...
      ClassLoader cl = null;
      
      cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);

      Thread.currentThread().setContextClassLoader(cl);
      
      return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
    }

  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4. ZygoteInit.java # zygoteInit()

说明

ZygoteInit.java#handleSystemServerProcess() 调用该方法，在通过 RuntimeInit.java#applicationInit() 来返回一个反射SystemServer.java#main() 的Runnable。

源码

public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
    if (RuntimeInit.DEBUG) {
      Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
    }

    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
    RuntimeInit.redirectLogStreams();

    RuntimeInit.commonInit();
    ZygoteInit.nativeZygoteInit();
    return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
1
2
3
4
5
6
7
8
9
10
11
12

5. RuntimeInit.java # applicationInit()

说明

RuntimeInit.java#applicationInit()通过RuntimeInit.java#findStaticMain()来返回一个MethodAndArgsCaller。

源码

//RuntimeInit.java # applicationInit()
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) {
        //...
        return findStaticMain(args.startClass, args.startArgs, classLoader);
}

//RuntimeInit.java # findStaticMain()
//找到SystemServer的main()方法并返回回去
protected static Runnable findStaticMain(String className, String[] argv,
            ClassLoader classLoader) {
    	//拿到SystemService.class
        Class<?> cl = Class.forName(className, true, classLoader);
       	//拿到main()方法
        Method m  = cl.getMethod("main", new Class[] { String[].class });
        //...
        return new MethodAndArgsCaller(m, argv);
}


static class MethodAndArgsCaller implements Runnable {
       	//想要调用的方法
        private final Method mMethod;
		//调用方法时需要传入的参数
        private final String[] mArgs;

    	//构造方法，传入SystemServer的main()方法与需要的参数
        public MethodAndArgsCaller(Method method, String[] args) {
            mMethod = method;
            mArgs = args;
        }
		//调用run方法，可以反射调用SystemServer的main()方法
        public void run() {
            try {
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (Exception ex) {
               //...
            }
        }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

6. SystemServer.java # main()

说明

Zygote孵化出的 SystemServer进程，通过调用 r.run()方法进入到SystemServer.java # main() ，这是 SystemServer进程真正的入口。它开始了 SystemServer的生命历程。它调用了 SystemServer.java # run() 进行一些配置后，就开始了三大主要任务：

1. 启动引导服务，如AMS，PMS等
2. 启动核心服务
3. 启动其他服务

源码

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

private void run() {
    try {
	  //一些系统设置
      //...
      // 准备Looper（在这个线程中）
      Looper.prepareMainLooper();
      // 加载动态库
      System.loadLibrary("android_servers");
      // 创建系统context
      createSystemContext();
      // 创建系统SystemServiceManager
      mSystemServiceManager = new SystemServiceManager(mSystemContext);
      //...
    } finally {
      traceEnd(); // InitBeforeStartServices
    }
    //启动服务
    try {
      traceBeginAndSlog("StartServices");
      // 启动引导服务。如AMS，PMS等，进去看
      startBootstrapServices();
      // 启动核心服务
      startCoreServices();
      // 启动其他服务
      startOtherServices();
      //停止线程池
      SystemServerInitThreadPool.shutdown();
    } catch (Throwable ex) {
      //...
    } finally {
      //...
    }
	//为当前的虚拟机初始化VmPolicy
    StrictMode.initVmDefaults(null);
	//...
    //死循环执行
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

7. SystemServer.java # startBootstrapServices()

说明

该方法用于启动系统 Boot引导级别的服务，例如 AMS（ActivityManagerService）、PowerManagerService、PackageManagerService（PKMS/PMS）等服务。

源码

private void startBootstrapServices() {
    //启动watchdog
    //尽早启动watchdog，如果在早起启动时发生死锁，我们可以让system_server
    //崩溃，从而进行详细分析
    final Watchdog watchdog = Watchdog.getInstance();
    watchdog.start();
    //...
    //阻塞等待installd完成启动
    Installer installer = mSystemServiceManager.startService(Installer.class);
    //启动ATM
    ActivityTaskManagerService atm = mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService();
    //启动服务AMS
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
    //启动服务PowerManagerService，并初始化power management
    mPowerManagerService = mSystemServiceManager.startService(
PowerManagerService.class);
    mActivityManagerService.initPowerManagement();
    //启动recovery system，以防需要重新启动
    mSystemServiceManager.startService(RecoverySystemService.class);
    //启动服务LightsService
    //管理led和显示背光，所以我们需要它来打开显示
    mSystemServiceManager.startService(LightsService.class);
    //启动服务DisplayManagerService
    //显示管理器需要在包管理器之前提供显示指标
    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
    // Boot Phases: Phase100: 在初始化package manager之前，需要默认的显示.
    mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
    //启动服务PackageManagerService(PKMS/PMS)
    mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
    //启动服务UserManagerService，新建目录/data/user/
    mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
    //为系统进程设置应用程序实例并开始。
    //设置AMS
    mActivityManagerService.setSystemProcess();
    //使用一个ActivityManager实例完成watchdog设置并监听重启，
	//只有在ActivityManagerService作为一个系统进程正确启动后才能这样做
    watchdog.init(mSystemContext, mActivityManagerService);
    //传感器服务需要访问包管理器服务、app ops服务和权限服务，
    //因此我们在它们之后启动它。
    //在单独的线程中启动传感器服务。在使用它之前应该检查完成情况。
    mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
        TimingsTraceLog traceLog = new TimingsTraceLog(
                SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.
TRACE_TAG_SYSTEM_SERVER);
        traceLog.traceBegin(START_SENSOR_SERVICE);
        startSensorService(); //启动传感器服务
        traceLog.traceEnd();
    }, START_SENSOR_SERVICE);
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

8. SystemServer.java # startCoreServices()

说明

启动核心服务，例如BatteryService,UsageStatsService,WebViewUpdateService,GpuService等等。

源码

private void startCoreServices() {
    //启动服务BatteryService，用于统计电池电量，需要LightService.
   mSystemServiceManager.startService(BatteryService.class);
    //启动服务UsageStatsService，用于统计应用使用情况
    mSystemServiceManager.startService(UsageStatsService.class);
    mActivityManagerService.setUsageStatsManager(
            LocalServices.getService(UsageStatsManagerInternal.class));
    //启动服务WebViewUpdateService
    //跟踪可更新的WebView是否处于就绪状态，并监视更新安装
    if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
        mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
    }
    //启动CachedDeviceStateService，跟踪和缓存设备状态
    mSystemServiceManager.startService(CachedDeviceStateService.class);
    //启动BinderCallsStatsService, 跟踪在绑定器调用中花费的cpu时间
    mSystemServiceManager.startService(BinderCallsStatsService.LifeCycle.class);
    //启动LooperStatsService，跟踪处理程序中处理消息所花费的时间。
    mSystemServiceManager.startService(LooperStatsService.Lifecycle.class);
    //启动RollbackManagerService，管理apk回滚
    mSystemServiceManager.startService(RollbackManagerService.class);
    //启动BugreportManagerService，捕获bugreports的服务
    mSystemServiceManager.startService(BugreportManagerService.class);
    //启动GpuService，为GPU和GPU驱动程序提供服务。
    mSystemServiceManager.startService(GpuService.class);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

9. SystemServer.java # startOtherServices

说明

启动其他的服务。

源码

private void startOtherServices() {
	...
    //启动TelecomLoaderService，通话相关核心服务
    mSystemServiceManager.startService(TelecomLoaderService.class);
 
	//Phase480:在接收到此启动阶段后，服务可以获得锁设置数据
    mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
 
    //Phase500:在接收到这个启动阶段之后，服务可以安全地调用核心系统服务，
    //如PowerManager或PackageManager。
    mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
	
	mActivityManagerService.systemReady(() -> {
        //Phase550:在接收到此引导阶段后，服务可以广播意图。
        mSystemServiceManager.startBootPhase(
                SystemService.PHASE_ACTIVITY_MANAGER_READY);
 
		//Phase600:在接收到这个启动阶段后，服务可以启动/绑定到第三方应用程序。
        //此时，应用程序将能够对服务进行绑定调用。
        mSystemServiceManager.startBootPhase(
        SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

三、 ActivityManagerService启动流程

ActivityManagerService服务由SystemServer进程在 startBootstrapServices()方法中启动，在AMS正式启动之前，SystemServer需要做几件事：

1. 初始化SystemContext，AMS的上下文将与SystemServer的保持一致
2. 创建SystemServiceManager对象，用来启动后续的服务
3. 启动三种服务（引导服务，核心服务，其他服务）
4. 在引导服务中启动AMS服务
5. 在其他服务中完成AMS的最后工作，即 systemReady

0. ActivityManagerService启动流程示意图

1. SystemServer.java # createSystemContext();

说明

在这个方法中，初始化了SystemContext，即SystemServer的上下文

源码

private void createSystemContext() {
    //创建ActivityThread对象。并调用该对象的attach方法
    ActivityThread activityThread = ActivityThread.systemMain();
    //获取system context
    mSystemContext = activityThread.getSystemContext();
    //设置系统主题
    mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
	//获取systemUI context
    final Context systemUiContext = activityThread.getSystemUiContext();
    //设置systemUI主题
    systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}
1
2
3
4
5
6
7
8
9
10
11
12

2. ActivityThread 对象创建与attach()方法

说明

ActivityThread拥有自己的looper以及handler，它可以代表事件处理线程。在attach()方法中主要就是创建了Instrumentation、Application和Context，

Instrumentation是Android中的一个工具类，它优先于应用中其他类被初始化，系统先创建它，再通过它来创建其他组件。

源码

public final class ActivityThread extends ClientTransactionHandler {
 
    ...
    //定义了AMS与应用通信的接口，拿到ApplicationThread的对象
    final ApplicationThread mAppThread = new ApplicationThread();
 
    //拥有自己的looper，说明ActivityThread确实可以代表事件处理线程
    final Looper mLooper = Looper.myLooper();
 
    //H继承Handler，ActivityThread中大量事件处理依赖此Handler
    final H mH = new H();
 
    //用于保存该进程的ActivityRecord
    final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
 
    //用于保存进程中的Service
    final ArrayMap<IBinder, Service> mServices = new ArrayMap<>();
 
    用于保存进程中的Application
    final ArrayList<Application> mAllApplications
        = new ArrayList<Application>();
    
    //构造函数
    @UnsupportedAppUsage
    ActivityThread() {
        mResourcesManager = ResourcesManager.getInstance();
    }
    
    private void attach(boolean system, long startSeq) {
        mSystemThread = system;
        //传入的system为0
        if (!system) {
            //应用进程的处理流程
            ...
        } else {
            //系统进程的处理流程，该情况只在SystemServer中处理
            //创建ActivityThread中的重要成员：Instrumentation、 Application 和 Context
            mInstrumentation = new Instrumentation();
            mInstrumentation.basicInit(this);

            //创建系统的Context
            ContextImpl context = ContextImpl.createAppContext(
                    this, getSystemContext().mPackageInfo);

            //调用LoadedApk的makeApplication函数
            mInitialApplication = context.mPackageInfo.makeApplication(true, null);
            mInitialApplication.onCreate();
        }

    }
    
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

3。 SystemServer.java # startBootstrapServices();

说明

SystemServer创建好系统上下文后，会创建一个SystemServerManager对象，其主要用于管理 SystemService 的创建、启动等生命周期，

ActivityManagerService也由它来创建。创建完成后，通过setSystemProcess()为系统进程设置应用程序实例并开始。

源码

private void startBootstrapServices() {
    ...
    //通过SystemServiceManager来启动AMS服务
    mActivityManagerService = mSystemServiceManager.startService(
        ActivityManagerService.Lifecycle.class).getService();
    //为AMS设置SystemServiceManager
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    //为AMS设置安装器
    mActivityManagerService.setInstaller(installer);
    
    ...
    //为系统进程设置应用程序实例并开始
    mActivityManagerService.setSystemProcess();
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4. SystemServiceManager.java # startService()

说明

SystemServiceManager 通过反射创建 SystemService 对象，并且还会将其添加到 mServices中。

1. 获取AMS.class
2. 实例化AMS
3. 将AMS注册到mServices，便于统一管理
4. 开启服务

源码

//1. 获取AMS.class
public SystemService startService(String className) {
    final Class<SystemService> serviceClass;
    try {
      //反射获取AMS类
      serviceClass = (Class<SystemService>) Class.forName(className);
    } catch (ClassNotFoundException ex) {
      
    }
    return startService(serviceClass);
}
//2. 实例化AMS对象
public <T extends SystemService> T startService(Class<T> serviceClass) {
    try {
      ...
      final T service;
      try {
        //反射实例化AMS  
        Constructor<T> constructor = serviceClass.getConstructor(Context.class);
        service = constructor.newInstance(mContext);
      } catch (InstantiationException ex) {
       。。。
      startService(service);
      return service;
    } finally {
      ...
    }
}

//3. 注册AMS，并开启AMS服务
public void startService(@NonNull final SystemService service) {
    // Register it.
    mServices.add(service);
    try {
      service.onStart();
    } catch (RuntimeException ex) {
      ...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

5. 实例化AMS对象

说明

SystemServiceManager 获取到 AMS.class 后，通过反射可以实例化AMS对象出来。ActivityManagerService构造函数初始化主要工作就是初始化一些变量。

在初始化过程中开启了mHandlerThread线程，这就是AMS线程，其中的消息由mHandler来处理。

源码

public ActivityManagerService(Context systemContext) {
    LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
    // AMS运行上下文与SystemServer一致
    mContext = systemContext;
    // 取出的是ActivityThread的静态变量sCurrentActivityThread（由最近的attach()设置而来）
    // mSystemThread就是SystemServer的ActivityTHread
    mSystemThread = ActivityThread.currentActivityThread();
    mUiContext = mSystemThread.getSystemUiContext();
    // 做一些设置，并运行HandlerThread中的run方法，其中包括但不限于Looper.prepare();
    // 在Looper.prepare()中有Looper的全局ThreadLocal，prepare()方法为当前线程设置一个looper()，并加到SThreadLocal中
    mHandlerThread = new ServiceThread(TAG,
        THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
    mHandlerThread.start();
    // 处理AMS中的消息
    // 为looper设置处理消息的handler
    mHandler = new MainHandler(mHandlerThread.getLooper());
    // UiHandler对应于Android中的UiThread
    mUiHandler = mInjector.getUiHandler(this);
    ...
    // 创建BroadcastQueue 前台广播对象，处理超时时长为10s
    mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
        "foreground", BROADCAST_FG_TIMEOUT, false);
    // 创建BroadcastQueue后台广播对象，处理超时时长为 60s
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
        "background", BROADCAST_BG_TIMEOUT, true);
    // 在Android10中还会新增分流广播对象
    mBroadcastQueues[0] = mFgBroadcastQueue;
    mBroadcastQueues[1] = mBgBroadcastQueue;

    // 创建ActiveServices对象，用于管理ServiceRecord对象（管理正在运行的Service)
    mServices = new ActiveServices(this);
    // 用于管理ContentProciderRecord对象（管理Provider）
    mProviderMap = new ProviderMap(this);
    
    ...
    mProcessCpuThread = new Thread("CpuTracker");//设置cpu监视线程
    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

6. ActivityManagerService.java # start()

说明

实例化AMS对象后，SystemServiceManager将该服务注册管理，并通过ActivityManagerService.Lifecycle.onStart()方法来间接调用AMS的start()方法，由此启动AMS服务。

在AMS的start()方法中，主要做了：

1. 移除所有的进程组
2. 启动CPU监控线程
3. 在本地服务注册AMS服务
4. 如果cpu监控线程初始化出了问题，打断当前线程。

源码

private void start() {
    // 溢出所有的进程组
    removeAllProcessGroups();
    // 启动CPU监控线程
    mProcessCpuThread.start();
    // 在本地服务注册表中注册服务
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    try {
      // 让出锁，等待CPU线程初始化完成，如果初始化出现问题，打断当前线程
      mProcessCpuInitLatch.await();
    } catch (InterruptedException e) {
      ...
      Thread.currentThread().interrupt();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7. ActivityManagerService.java # setSystemProcess()

说明

SystemServer在启动引导服务中，开启AMS后，还要通过setSystemProcess()为系统进程设置应用实例，并开始。AMS的setSystemProcess主要由五个功能：

1. 注册服务

2. 获取ApplicationInfo

3. 为ActivityThread安装 system application相关信息

4. 为system_server主进程开一个 ProcessRecord来维护进程的相关信息

   AMS作为线程，所在的进程就是 system_server进程

5. AMS进程管理

源码

public void setSystemProcess() {
    try {
      // 1. 注册服务
      ...
      ServiceManager.addService("permission", new PermissionController(this));
      ...
      // 2. 通过解析framework-res.apk里的AndroidManifest.xml获取ApplicationInfo（系统进程的APplicationInfo）
      ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
          "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
      // 为SystemThread(即之前实例化的ActivityThread)安装system
      // application的相关信息，将framework-res.apk对应的ApplicationInfo安装到LoadedApk中的mApplicationInfo
      mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

      // 为SystemServer主进程开启一个ProcessRecord来管理进程的相关信息
      synchronized (this) {
        ProcessRecord app = new ProcessRecordLocked(info, info.processName, false, 0);
        // 对 ProcessRecord 做一些赋值
        app.persistent = true;// 设置进程常驻
        app.pid = MY_PID;// 设置当前进程ID为system_server进程ID
        app.maxAdj = ProcessList.SYSTEM_ADJ;
        app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
        synchronized (mPidsSelfLocked) {
          mPidsSelfLocked.put(app.pid, app);// 初始化过后，放到mPidsSelfLocked中统一管理
        }
        ...
      }
    } catch (PackageManager.NameNotFoundException e) {
      ...
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

8. ActivityManagerService.java # systemReady()

说明

SystemServer在启动所有服务过后，就到了AMS的最后工作：systemReady();

AMS的 systemReady() 主要由三个任务：

1. 杀死哪些在AMS启动完成前已经存在的，而且不是常驻进程的进程。

   （需要注意：Java进程才会向AMS注册，而一般的Native进程不会想AMS注册，所以此处杀死的是一些Java进程）

2. 调用传入的Runnable参数，主要是监控native的crash，启动webview，启动SystemUI，以及通知其他服务进行 systemReady,systemRunning等方法。

3. 启动 Launcher APP，即 Home Activity，启动结束后，发送 ACTION_BOOT_COMPLETED 广播。

源码

SystemServer.java # startOtherServices()

private void startOtherServices(){
    ...
    mActivityManagerService.systemReady(()->{
        
    });
}
1
2
3
4
5
6

ActivityManagerService.java # systemReady()

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    traceLog.traceBegin("PhaseActivityManagerReady");
    synchronized (this) {
      if (mSystemReady) {
        // 第一次进入mSystemReady为false，不走该流程
        if (goingCallback != null) {
            //第二次进来，则运行传入的runnable
          goingCallback.run();
        }
        return;
      }
      ...
      // 主要时调用一些关键服务SystemReady相关的函数
      // 进行一些等待AMS初始完，才能进行的工作
      mUserController.onSystemReady();
      mRecentTasks.onSystemReadyLocked();
      mAppOpsService.systemReady();
      // 最后设置systemReady为true
      mSystemReady = true;
    }

    ArrayList<ProcessRecord> procsToKill = null;
    synchronized (mPidsSelfLocked) {
      for (int i = mPidsSelfLocked.size() - 1; i >= 0; i--) {
        // mPidsSelfLocked中保存着当前正在运行的所有进程的信息
        ProcessRecord proc = mPidsSelfLocked.valueAt(i);
        // 收集一些不用的进程
        if (!isAllowedWhileBooting(proc.info)) {
          if (procsToKill == null) {
            procsToKill = new ArrayList<ProcessRecord>();
          }
          procsToKill.add(proc);
        }
      }
    }
    // 收集已启动的进程并杀死，除了persistent常驻进程
    synchronized (this) {
      if (procsToKill != null) {
        for (int i = procsToKill.size() - 1; i >= 0; i--) {
          ProcessRecord proc = procsToKill.get(i);
          removeProcessLocked(proc, true, false, "system update done");
        }
      }
      // 至此系统准备完毕
      mProcessesReady = true;
    }

    // 调用参数传入的runnable对象
    if (goingCallback != null)
      goingCallback.run();
   
    // 调用所有系统服务的onStartUser接口
    mSystemServiceManager.startUser(currentUserId);

    // 启动persistent为1的application所在的进程
    startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);

    //----------在这里启动 Home Activity ---------------
    // 启动HomeActivity即LauncherActivity
    // Android10改为交给ATM管理Activity，此时还是由AMS来开启
    startHomeActivityLocked(currentUserId, "systemReady");

    // 当启动结束后，发送ACTION_BOOT_COMPLETED广播
    ...
    long ident = Binder.clearCallingIdentity();
    try {
        //发送广播 ACTION_USER_STARTED
        Intent intent = new Intent(Intent.ACTION_USER_STARTED);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
            | Intent.FLAG_RECEIVER_FOREGROUND);
        intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
        broadcastIntentLocked(null, null, intent,
            null, null, 0, null, null, null, OP_NONE,
            null, false, false, MY_PID, SYSTEM_UID,
            currentUserId);
        //发送广播 ACTION_USER_STARTING
        intent = new Intent(Intent.ACTION_USER_STARTING);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
        intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
        broadcastIntentLocked(null, null, intent,
            null, new IIntentReceiver.Stub() {
              @Override
              public void performReceive(Intent intent, int resultCode, String data,
                  Bundle extras, boolean ordered, boolean sticky, int sendingUser)
                  throws RemoteException {
              }
            }, 0, null, null,
            new String[] { INTERACT_ACROSS_USERS }, OP_NONE,
            null, true, false, MY_PID, SYSTEM_UID, UserHandle.USER_ALL);
      } catch (Throwable t) {
        Slog.wtf(TAG, "Failed sending first user broadcasts", t);
      } finally {
        Binder.restoreCallingIdentity(ident);
      }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

四、 Launcher App (Home Activity)启动流程

AMS（ActivityManagerService）启动的最后一步就是开启 Home Activity。Home Activity就是我们所知的手机桌面，它展示有自定义内容，以及各种APP的图标，通过点击APP的桌面图标，可以打开我们安装好的APP。

0. Launcher APP 启动流程示意图

AMS启动完成的最后一步 systemReady() 中，发起了打开HomeActivity的请求，通过 Socket ，让 Zygote 孵化器进程得知，并由 Zygote 进程孵化出一个 App 进程，并打开 Activity 。

1. ActivityManagerService.java # startHomeActivityLocked()

说明

在 ActivityManagerService.java # systemReady()中，通过该方法启动Home Activity。在Android10.0之后，改为交给ActivityTaskManagerService(ATM)来管理Activity，此时仍然由AMS来开启。

源码

boolean startHomeActivityLocked(int userId, String reason) {
    ...
    mActivityStartController.startHomeActivity(intent, aInfo, myReason);
}
1
2
3
4

2. ActivityStartController.java # startHomeActivity()

说明

ActivityStartController的该方法主要任务是

1. 获取ActivityStarter，
2. 做一些设置，
3. 调用ActivityStarter.java # execute()方法进行真正的Home Activity启动逻辑。

源码

void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason) {
    // 放到栈顶
    mSupervisor.moveHomeStackTaskToTop(reason);

    // 1.通过ActivityStarter的工厂模式获取ActivityStarter
    // 2.做一些设置
    // 3.执行ActivityStarter.execute()，这是真正的启动逻辑
    mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
        .setOutActivity(tmpOutRecord)
        .setCallingUid(0)
        .setActivityInfo(aInfo)
        .execute();
    ...
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. ActivityStarter.java # execute() ，startActivity() 与 startActivityUnchecked()

说明

ActivityStarter的execute()方法才是真正进入Home Activity启动逻辑的入口，通过多次调用同名函数ActivityStarter.java # startActivity()来进行打开Home Activity前的设置。

源码

int execute(){
    try{
        if(mRequest.mayWait){
            return startActivityMayWait(...);
        }else{
            return startActivity(...);
        }
    }finally{
        //回调，告知controller，Activity开启完成
        onExecutionComplete();
    }
}

//逐个调用同名函数startActivity()后，进入到最后一个startActivity()方法
private int startActivity(...){
    // 逐步startActivity，进入到这里（主键减少参数传递，并且减少一个方法的代码量
    try {
      // 演示布局
      mService.mWindowManager.deferSurfaceLayout();
      // 调用 startActivityUnchecked 一路调用到resumeFocusedStacksTopActivities()
      result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
          startFlags, doResume, options, inTask, outActivity);
    } finally {
        ...
    }
    ...
}


//最后调用到startActivityUnchecked()
private int startActivityUnchecked(...){
    //设置、计算一些属性
    ...
    //交给ActivityStackSupervisor来启动
    mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
            mOptions);
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

4. ActivityStackSupervisor.java # resumeFocusedStackTopActivityLocked()

说明

ActivityStackSupervisor中又进入到ActivityStack

源码

boolean resumeFocusedStackTopActivityLocked(...) {

        if (targetStack != null && isFocusedStack(targetStack)) {
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }

        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || !r.isState(RESUMED)) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        } else if (r.isState(RESUMED)) {
            mFocusedStack.executeAppTransition(targetOptions);
        }

        return false;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5. ActivityStack.java # resumeTopActivityUncheckedLocked() 、 resumeTopActivityInnerLocked()

说明

ActivityStack又通过ActivityStackSupervisor来通知AMS来启动新进程

源码

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    ...
    result = resumeTopActivityInnerLocked(prev, options);
    ...
}

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    
    ...
    // 大致在源码2900行左右
    mStackSupervisor.startSpecificActivityLocked(next, true, false);
    ...
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6. ActivityStackSupervisor.java # startSpecificActivityLocked()

说明

主要任务是调用 AMS.startProcessLocked() 来通知AMS打开新进程

源码

void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
        // 判断想要打开的activity的application是否正在运行
        ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                r.info.applicationInfo.uid, true);

        if (app != null && app.thread != null) {
            try {
                //如果已经打开了
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
               ...
            }
        }
		//如果没打开，即Home Activity之前不可能打开，就调用AMS的startProcessLocked方法去打开Home Activity即Launcher进程
        mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
                "activity", r.intent.getComponent(), false, false, true);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7. ActivityManagerService.java # startProcessLocked()、startProcess()

说明

AMS依次调用多各同名函数 startProcessLocked(), 最后调用到真正请求打开新进程的方法startProcess()

源码

//这里只看最后一次调用到的startProcessLocked()
private boolean startProcessLocked(...){
    ...
    //为ProcessRecord设置一些参数
    ...
    final ProcessStartResult startResult = startProcess(...);
}

private ProcessStartResult startProcess(String hostingType, String entryPoint,
      ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
      String seInfo, String requiredAbi, String instructionSet, String invokeWith,
      long startTime) {
    try {
      final ProcessStartResult startResult;
      if (hostingType.equals("webview_service")) {
        //如果是要启动 webview
        startResult = startWebView(entryPoint,
            app.processName, uid, uid, gids, runtimeFlags, mountExternal,
            app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
            app.info.dataDir, null,
            new String[] { PROC_START_SEQ_IDENT + app.startSeq });
      } else {
        // 启动应用程序进程
        startResult = Process.start(entryPoint,
            app.processName, uid, uid, gids, runtimeFlags, mountExternal,
            app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
            app.info.dataDir, invokeWith,
            new String[] { PROC_START_SEQ_IDENT + app.startSeq });
      }
      ...
      return startResult;
    } finally {
      ...
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

8. ZygoteProcess.java # zygoteSendArgsAndGetResult()

说明

从AMS中调用Process.start()到通过socket发送消息给Zygote进程，通知创建新进程的调用过程如下：

• Process.java

  • start()

• ZygoteProcess.java

  • start()
  • startViaZygote()
  • zygoteSendArgsAndGetResult()

由startViaZygote()方法对启动应用需要的参数进行拼接，最后进入到zygoteSendArgsAndGetResult()方法

源码

ZygoteProcess.java # startViaZygote() 主要任务是

private Process.ProcessStartResult startViaZygote(...)
      throws ZygoteStartFailedEx {
    ArrayList<String> argsForZygote = new ArrayList<String>();

    // 创建单链表argsForZygote并将应用的启动参数保存在其中
    // --runtime-args, --setuid=, --setgid=,
    // and --setgroups= must go first
    argsForZygote.add("--runtime-args");
    argsForZygote.add("--setuid=" + uid);
    
    ...

    if (startChildZygote) {
      argsForZygote.add("--start-child-zygote");
    }

    argsForZygote.add(processClass);

    if (extraArgs != null) {
      for (String arg : extraArgs) {
        argsForZygote.add(arg);
      }
    }

    // 将拼接好的参数，交给 zygoteSendArgsAndGetResult() 通过socket发送消息给 Zygote进程。
    synchronized (mLock) {
      return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

ZygoteProcess.java # zygoteSendArgsAndGetResult() 主要任务是与Zygote进程进行socket通信，告知需要创建子进程，并附带应用启动需要的参数信息。

//主要任务就是鱼Zygote进程进行socket通信
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
      ZygoteState zygoteState, ArrayList<String> args)
      throws ZygoteStartFailedEx {
    ...
      final BufferedWriter writer = zygoteState.writer;
      final DataInputStream inputStream = zygoteState.inputStream;
      
      writer.write(Integer.toString(args.size()));
      writer.newLine();

      for (int i = 0; i < sz; i++) {
        String arg = args.get(i);
        writer.write(arg);
        writer.newLine();
      }

      writer.flush();
    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

五、 Zygote fork()子进程，子进程入口为ActivityThread.main()

Zygote的启动流程我们之前有讲到过，它最后会通过ZygoteServer.java # runSelectLoop()进入循环等待，用来接收Socket发来的消息，用来fork出其他应用进程，比如Launcher进程。

Zygote孵化出的第一个服务进程是SystemServer进程，Zygote孵化出的第一个应用进程是ActivityManagerService.systemReady()时启动的 Home Activity。Zygote进程都是通过Linux的fork()函数孵化出新的进程。

不论是服务进程还是应用进程，进程的入口都是ActivityThread.main()。我们上面已经讨论过 SystemServer进程。接下来讨论通过Zygote孵化出一个应用进程：

0. Zygote fork()到应用进程启动流程

1.ZygoteConnection.java # processOneCommand()

说明

Zygote进程接收socket消息，实际上是在ZygoteConnection.java # processOneCommand() 中的 readArgumentList()方法进行读取。如果需要新建进程，将会进入Zygote.forkAndSpecialize()方法中。

源码

Runnable processOneCommand(ZygoteServer zygoteServer){
    //读取socket消息
    args = readArgumentList();
    //根据消息内容决定要做什么行为
    ...
    pid = Zygote.forkAndSpecialize(...);
    try{
        if(pid == 0){
            //如果是fork出来的进程
            return handleChildProc(...);
        }else{
            //如果仍然是Zygote进程 
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. Zygote.java # forkAndSpecialize()

说明

这里主要是调用dalvik中ZygoteHooks的preFork进行预处理，再调用postForkCommon进行fork后进程的处理

源码

 public static int forkAndSpecialize(..){
     VM_HOOKS.preFork();//VM_HOOKS是ZygoteHooks实例
     int pid = nativeForkAndSpecialize(...);//native方法进行fork
     VM_HOOKS.postForkCommon();//处理fork后的进程
 }
1
2
3
4
5

3. ZygoteHooks.java # preFork()

说明

在fork进程之前做的准备：

1. 关闭四个守护进程：
   • HeapTaskDaemon（Java堆整理线程）
   • ReferenceQueueDaemon（引用队列线程）
   • FinalizerDaemon（析构线程）
   • FinalizerWatchdogDaemon（析构监控线程）
2. 等待所有线程停止
3. ative层的fork前的处理

源码

public void preFork() {
        Daemons.stop();//先调用目标线程interrupt()方法，在调用join方法等待线程执行完成。（改为同步等待，确保关闭完成）
        waitUntilAllThreadsStopped();//线程消息都存在"/proc/self/task"中
        token = nativePreFork();
}
1
2
3
4
5

4. Zyote.java # nativeForkAndSpecialize()

说明

任务是fork子进程。方法是JNI调用com_android_internal_os_Zygote.cpp # com_android_internal_os_Zygote_nativeForkAndSpecialize.

源码

static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(...) {
    
    return ForkAndSpecializeCommon(env, uid, gid, gids, runtime_flags,
            rlimits, capabilities, capabilities, mount_external, se_info,
            se_name, false, fdsToClose, fdsToIgnore, is_child_zygote == JNI_TRUE,
            instructionSet, appDataDir);
}
1
2
3
4
5
6
7

5. com_android_internal_os_Zygote.cpp # ForkAndSpecializeCommon()

说明

在这里真正fork进程，在Android10.0之后，其中的fork()方法将会被抽取出去。fork完成后，会进行进程的一些资源处理，selinux权限处理，并在最后反射调用Zygote的callPostForkChildHooks() 进行Java堆线程的一些处理

源码

static pid_t ForkAndSpecializeCommon(...) {
  ...
  //  ----------下面这部分代码在Android10.0被单独抽到ForkCommon()方法中----------
  pid_t pid = fork();
  //fork子进程，这里执行一次，会返回两次
  //pid = 0 表示fork成功，且当前程序在fork的子进程中执行
  //pid > 0 表示fork成功，且当前程序在Zygote中执行，pid为fork的子进程的真正PID（进程ID）

  if (pid == 0) {
    //进入子进程
    PreApplicationInit();

    //关闭并清除文件描述符
    if (!DetachDescriptors(env, fdsToClose, &error_msg)) {
      fail_fn(error_msg);
    }
    
    //  ----------下面这部分代码在Android10.0被单独抽到SpecializeCommon()方法中----------
    if (!is_system_server && getuid() == 0) {
        //对于非system_server的子进程，创建进程组
        int rc = createProcessGroup(uid, getpid());
        ...
    }
    //设置group
    if (!SetGids(env, javaGids, &error_msg)) {
      fail_fn(error_msg);
    }
    //设置资源限制
    if (!SetRLimits(env, javaRlimits, &error_msg)) {
      fail_fn(error_msg);
    }
    //selinux上下文，这部分写法与Android10.0中的大同小异
    rc = selinux_android_setcontext(uid, is_system_server, se_info_c_str, se_name_c_str);
    //设置子进程的signal信号处理函数为默认函数
    UnsetChldSignalHandler();
    //反射调用zygote.callPostForkChildHooks()
    env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, runtime_flags,
                              is_system_server, is_child_zygote, instructionSet);
    ...
  return pid;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

6. ZygoteHooks.java # postForkCommon()

说明

native层进行进程fork之后，启动Zygote的四个Daemon守护线程。

源码

public void postForkCommon() {
    Daemons.startPostZygoteFork();
    nativePostZygoteFork();
}
1
2
3
4

7. ZygoteConnection.java # handleChildProc()

说明

执行该方法时，是在子进程的上下文中，Zygote进程不会走到这一步。该方法最终获取到需要执行的ActivityThread的main()

源码

private Runnable handleChildProc(...){
    //关闭socket
    closeSocket();
    ...
    if (!isZygote) {
       //App进程将会进入这里，调用目标类的main()
       return ZygoteInit.zygoteInit(...);
    } else {
       return ZygoteInit.childZygoteInit(...);
    }
}
1
2
3
4
5
6
7
8
9
10
11

8. ZygoteInit.java # zygoteInit()

说明

进行一些环节的初始化，启动Binder进程等操作。并把ActivityThread

源码

public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
    ...
    RuntimeInit.commonInit();//初始化运行环境
    ZygoteInit.nativeZygoteInit();//启动Binder线程池进程
    //调用程序入口函数
    return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
1
2
3
4
5
6
7

RuntimeInit.java # applicationInit()

protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) {
        ...
        return findStaticMain(args.startClass, args.startArgs, classLoader);
}
1
2
3
4
5

RuntimeInit.java # findStaticMain()

把反射得来的 ActivityThread的main()入口返回给ZygoteInit的main()方法（此时程序运行在之前fork出来的新进程，不影响Zygote进程），通过caller.run()进行调用。

protected static Runnable findStaticMain(String className, String[] argv,
            ClassLoader classLoader) {
        Class<?> cl;
        try {
            cl = Class.forName(className, true, classLoader);
        } catch (ClassNotFoundException ex) {}
        Method m;
        try {
            m = cl.getMethod("main", new Class[] { String[].class });//反射获取main()方法
        } catch (NoSuchMethodException ex) {}
       ...
        return new MethodAndArgsCaller(m, argv);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

RuntieInit.java # MethodAndArgsCaller.class

static class MethodAndArgsCaller implements Runnable {
        private final Method mMethod;
        private final String[] mArgs;

        public MethodAndArgsCaller(Method method, String[] args) {
            mMethod = method;
            mArgs = args;
        }
    	//封装到run方法中，暴露出去
        public void run() {
            try {
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (IllegalAccessException ex) { }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

至此，新的应用程序进程以及创建成功，并以ActivityThread.main()为起点，进入消息循环Looper，开始了应用程序。

单单这样是不够的，应用程序还需要Activity等各种组件，所以接下来就正式进入到从ActivityThread.main()到Activity.onCreate()的历程

六、 Activity的启动流程（从ActivityThread到Activity）

0. Activity启动流程图

1. ActivityThread.java # main()

说明

由 ZygoteInit.java # main() 的 caller.run()方法，正式进入APP的主线程的main()入口。这里为主线程处理，首先创建ActivityThread对象，调用attach进行处理，最终进入Looper循环。

源码

public static void main(String[] args) {
        ...
        //在当前进程中的LocalThread中存放当前线程的Looper
        Looper.prepareMainLooper();
        ...
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
		//死循环一旦退出，表面程序结束，抛出RuntieException
        Looper.loop();
        ...
}
//第一个参数表示当前进程是应用进程还是服务进程（如SystemServer）
private void attach(boolean system, long startSeq){
    sCurrentActivityThread = this;
    mSystemThread = system;
    if(!system){
        //如果应用进程
        ...
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        final IActivityManager mgr = ActivityManager.getService();
        try {
            //通过Binder调用AMS的attachApplication方法，进行activity的启动
            mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
		...
    } else {
        //通过system_server启动ActivityThread对象
        ...
    }
    // 为 ViewRootImpl 设置配置更新回调，
    ViewRootImpl.ConfigChangedCallback configChangedCallback
            = (Configuration globalConfig) -> {
        synchronized (mResourcesManager) {
			...
        }
    };
    //添加回调监听接口
    ViewRootImpl.addConfigCallback(configChangedCallback);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2. ActivityManagerService.java # attachApplication()

说明

清除一些没有用的记录，最终调用ActivityStackSupervisor.java # realStartActivityLocked()方法进行Activity的启动。

源码

private final boolean attachApplicationLocked(IApplicationThread thread,long startSeq) {
    synchronized (this) {
      int callingPid = Binder.getCallingPid();
      final int callingUid = Binder.getCallingUid();
      final long origId = Binder.clearCallingIdentity();
      attachApplicationLocked(thread, callingPid, callingUid, startSeq);
      Binder.restoreCallingIdentity(origId);
    }
}

private final boolean attachApplicationLocked(IApplicationThread thread,
      int pid, int callingUid, long startSeq) {
    ...
    //如果当前的Application记录仍然依附在之前的进程，清除掉
    if (app.thread != null) {
      handleAppDiedLocked(app, true, true);
    }
    ...
    if (normalMode) {
      try {
          //直接调用ActivityStackSupervisor的方法
          //在Android10中，将会把该任务交给ATM，ATM中层层调用才到ActivityStackSupervisor的该方法
        if (mStackSupervisor.attachApplicationLocked(app)) {
          didSomething = true;
        }
      } catch (Exception e) {
        ...
      }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3. ActivityStackSupervisor.java # attachApplicationLocked()

说明

在该方法中，通过realStartActivityLocked()真正地准备去启动Activity。

在realStartActivityLocked()之后层层调用的主要过程：

1. 等到所有Activity都onPause之后才会去启动新Activity
2. 为ClientTransaction设置LaunchActivityItem作为callback
3. 通过ClientLifecycleManager.scheduleTransaction()来发起启动Activity
4. 层层调用来到ActivityThread的scheduleTransaction()。ActivityThread继承自ClientTransactionHandler
5. ActivityThread的scheduleTransaction()主动通过sendMessage发出EXECUTE_TRANSACTION消息
6. ActivityThread的Handler收到消息后，通过TransactionExecutor.execute() 来回调之前设置的 LaunchActivityItem.execute()，从而通过ActivityThread的引用调用其 handleLaunchActivity()方法
7. handleLaunchActivity()中，调用performLaunchActivity()

源码

ActivityStackSupervisor.java # attachApplicationLocked()

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    ...
    if(realStartActivityLocked(activity,app,top==activity,true)){
        didSomething = true;
    }
}
1
2
3
4
5
6

ActivityStackSupervisor.java # realStartActivityLocked()

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
		//等到所有的onPause()方法执行结束才会去启动新的Activity
        if (!allPausedActivitiesComplete()) {
           ...
            return false;
        }
    	//添加 LaunchActivityItem
		final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                        r.appToken);
        //LaunchActivityItem.obtain()作为回调参数
        clientTransaction.addCallback( LaunchActivityItem.obtain(new Intent(r.intent, ...));

        ...
        try{//设置生命周期状态
            final ActivityLifecycleItem lifecycleItem;
            if (andResume) {
                 lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
            } else {
                 lifecycleItem = PauseActivityItem.obtain();
            }
            clientTransaction.setLifecycleStateRequest(lifecycleItem);
        	//mService.getLifecycleManager返回的是ClientLifecycleManager
            mService.getLifecycleManager().scheduleTransaction(clientTransaction);

         } catch (RemoteException e) {
            if (r.launchFailed) {
                //第二次启动失败，finish activity
                stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED,null,"2nd-crash", false);
                    return false;
                }
				//第一次失败，重启进程并重试
                r.launchFailed = true;
                app.activities.remove(r);
                throw e;
            }
        } finally {
            endDeferResume();
        }
		...
        return true;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

ClientLifycycleManager.java # scheduleTransaction()

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();
        if (!(client instanceof Binder)) {
            transaction.recycle();
        }
}
1
2
3
4
5
6
7

ClientTransaction.java # schedule()

里面的mClient是 IApplicationThread 实例，传入的是app.thread，即ActivityThread实例

public void schedule() throws RemoteException {
	mClient.scheduleTransaction(this);
}
1
2
3

ActivityThread.java # scheduleTransaction()

这里的scheduleTransaction()没有实现，调用的是父类的方法，ActivityThread.java继承自ClientTransactionHandler.java

ClientTransactionHandler.java # scheduleTransaction()

void scheduleTransaction(ClientTransaction transaction) {
    //之前有传入LaunchActivityItem.obtain()作为一个回调，在这里将会被调用,只会更新一些ActivityThread的变量、状态
	transaction.preExecute(this);
    //发送到ActivityThread的handler里
	sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
1
2
3
4
5
6

ActivityThread.java # sendMessage()

private void sendMessage(int what, Object obj) {
        Message msg = Message.obtain();
        ...
        mH.sendMessage(msg);
}
1
2
3
4
5

最后有ActivityThread.java中的mH来处理消息

ActivityThread.java -> H.class
class H extends Handler{
    ...
    public void handleMessage(){
        ...
        case EXECUTE_TRANSACTION:
             final ClientTransaction transaction = (ClientTransaction) msg.obj;
        	 //调用ClientTransaction中的callbacks，如之前加入的LaunchActivityItem.execute()
             mTransactionExecutor.execute(transaction);
             if (isSystem()) {
                  transaction.recycle();
             }
             break;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

TransactionExecutor.java # execute()

public void execute(ClientTransaction transaction) {
        executeCallbacks(transaction);
        executeLifecycleState(transaction);
}

public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        
        final int size = callbacks.size();
        for (int i = 0; i < size; ++i) {
            ...
            item.execute(mTransactionHandler, token, mPendingActions);
            ...
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

LaunchActivityThread.java # execute()

LaunchActivityThread是之前构造 ClientTransaction 时设置的 callback ，在这里被调用execute()方法，最后让 ActivityThread 调用handleLaunchActivity()方法

public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        //这里的client是ActivityThread（ActivityThread继承自ClientTransactionHandler）
        client.handleLaunchActivity(r, pendingActions, null );
}
1
2
3
4
5

ActivityThread.java # handleLaunchActivity()

public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
        。。。
        //初始化WindowManagerGlobal
        WindowManagerGlobal.initialize();
		//调用performLaunchActivity，来处理Activity
        final Activity a = performLaunchActivity(r, customIntent);
		...
        return a;
}
1
2
3
4
5
6
7
8
9
10

4. ActivityThread.java # performLaunchActivity()

说明

该方法是启动activity的核心实现。

获取ComponentName, Context, 通过 Instrumentation.java # newActivity() 来反射实例化Activity，并设置一些内容，最后还通过Instrumentation.java # callActivityOnCreate()方法来回调Activity的 onCreate() 方法

源码

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        //获取ComponentName
        ComponentName component = r.intent.getComponent();
        //获取context
        ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
        //通过Instrumentation反射获取Activity实例
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
        } catch (Exception e) {}
    	//回调activity的attach()方法与onCreate()方法
        try {    
            //回调activity的attach方法
            activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.configCallback);
			//设置intent
            if (customIntent != null) {
                activity.mIntent = customIntent;
            }
          	//设置主题
            int theme = r.activityInfo.getThemeResource();
            if (theme != 0) {
                activity.setTheme(theme);
            }
			//通过Instrumentation来回调activity的onCreate()方法
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            //加入mActivities Map统一管理
            mActivities.put(r.token, r);
        } catch (SuperNotCalledException e) {
           。。。
        }
        return activity;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

5. Instrumentation.java # callActivityOnCreate()

说明

callActivityOnCreate() 先进行activity的onCreate()的预处理，再去调用activity的onCreate()，最后处理activity的onCreate()后的信息处理

源码

public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
        activity.performCreate(icicle);
        postPerformCreate(activity);
}
1
2
3
4
5

Activity.java # performCreate()

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    ...
    if (persistentState != null) {
        onCreate(icicle, persistentState);
    } else {
        onCreate(icicle);
    }
    mFragments.dispatchActivityCreated();
}
1
2
3
4
5
6
7
8
9

至此，Activity的onCreate()方法回调完成，应用启动流程完成，APP应用程序真正启动起来。