应用启动流程

Activity 启动流程

• 系统启动后通过 android.intent.action.MAIN 和 android.intent.category.HOME 启动 Launcher
• Launcher 通过 PackageManager 遍历已安装应用，通过 android.intent.action.MAIN 和 android.intent.category.LAUNCHER 获取所有应用的入口

@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        startActivityForResult(intent, -1);
    }
}

• 用户点击图标时通过 Activity.startActivity 启动应用，Activity.startActivity 最终会调用Activity.startActivityForResult，对应于 RequestCode 小于零

// Activity
public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
    Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity (
            this, mMainThread.getApplicationThread(), mToken,
            this, intent, requestCode, options);
    if (ar != null) {
        mMainThread.sendActivityResult(
            mToken, mEmbeddedID, requestCode, ar.getResultCode(),
            ar.getResultData()
        );
    }
}

// Instrumentation
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    try {
        int result = ActivityManagerNative.getDefault()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()),
                token, target != null ? target.mEmbeddedID : null,
        requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
    }
    return null;
}

ActivityManagerNative.getDefault().activityPaused(token);

• 在 startActivityForResult 中会获取 ActivityThread 中的 IApplicationThread 对象，然后调用 Instrumentation.execStartActivity，该方法会通过 IActivityManager 与 AMS 通讯，参数中会把当前进程的 IApplicationThread 引用传递给 AMS，AMS 保存请求参数后，通过 IApplicationThread 通知当前栈顶 Activity 执行 ActivityThread.handlePauseActivity方法，进而执行 Instrumentation.callActivityOnPause 和 Activity.onPause 方法，onPause 执行结束后通过 IActivityManager.activityPaused 方法通知系统并继续 Activity 启动流程

abstract class ApplicationThread extends Binder implements IApplicationThread {}
abstract class ActivityManagerNative extends Binder implements IActivityManager {}

• 首先判断是否创建了应用进程，如果进程没创建，AMS 会通过 Socket 和 Zygote 通讯，通知 Zygote 进程 fork 一个新的进程，并执行 ActivityThread.main 方法

// ActivityManagerService.java
private final void startProcessLocked(ProcessRecord app, String hostingType,
          String hostingNameStr, String abiOverride, String entryPoint,
          String[] entryPointArgs) {

    entryPoint = "android.app.ActivityThread";
    Process.start(entryPoint, app.processName, uid, uid, gids, debugFlags,
            mountExternal, app.info.targetSdkVersion, app.info.seinfo, 
            requiredAbi, instructionSet, app.info.dataDir, entryPointArgs);
}

//Process
public static final ProcessStartResult start(final String processClass,
                              final String niceName,
                              int uid, int gid, int[] gids,
                              int debugFlags, int mountExternal,
                              int targetSdkVersion,
                              String seInfo,
                              String abi,
                              String instructionSet,
                              String appDataDir,
                              String[] zygoteArgs) {

    return startViaZygote(processClass, niceName, uid, gid, gids,
        debugFlags, mountExternal, targetSdkVersion, seInfo,
        abi, instructionSet, appDataDir, zygoteArgs);
}

• 该方法会初始化 MainLooper，执行 Application 的生命周期方法，如果判断需要启动 Activity，则继续执行 scheduleLaunchActivity 方法，并最终执行 Instrumentation的newAcvitity、callActivityOnCreate、callActivityOnStart、callActivityOnResume方法，ActivityThread 在执行完 onResume 方法后，会通过willActivityBeVisible 方法告知AMS，这时系统会通知栈顶Activity执行 onStop 方法

// ActivityThread
public static void main(String[] args) {
    Looper.prepareMainLooper();
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    Looper.loop();
}

你了解安卓系统启动流程吗

当按电源键触发开机，首先会从 ROM 中预定义的地方加载引导程序 BootLoader 到 RAM 中，并执行 BootLoader 程序启动 Linux Kernel， 然后启动用户级别的第一个进程： init 进程

init 进程会解析 init.rc 脚本做一些初始化工作，包括挂载文件系统、创建工作目录以及启动系统服务进程，包括 Zygote、ServiceManager、Media 等

在 Zygote 中会进一步去启动 system_server 进程，然后在 system_server 进程中会启动 AMS、WMS、PMS 等服务，等这些服务启动之后，AMS 中就会启动 Launcher 应用来现实桌面

system_server 为什么要在 Zygote 中启动，而不是由 init 直接启动呢

Zygote 作为一个孵化器，可以提前加载一些资源，这样 fork() 时基于 Copy-On-Write 机制创建的其他进程就能直接使用这些资源，而不用重新加载。比如 system_server 就可以直接使用 Zygote 中的 JNI 函数、共享库、常用的类、以及主题资源

为什么要专门使用 Zygote 进程去孵化应用进程，而不是让 system_server 去孵化呢

首先 system_server 相比 Zygote 多运行了 AMS、WMS 等服务，这些对一个应用程序来说是不需要的。另外进程的 fork() 对多线程不友好，仅会将发起调用的线程拷贝到子进程，这可能会导致死锁，而 system_server 中肯定是有很多线程的

能说说具体是怎么导致死锁的吗

fork() 时只会把调用线程拷贝到子进程、其他线程都会立即停止，那如果一个线程在 fork() 前占用了某个互斥量，fork() 后被立即停止，这个互斥量就得不到释放，再去请求该互斥量就会发生死锁了

Zygote 为什么不采用 Binder 机制进行 IPC 通信

1、多线程问题：Linux中fork进程是不推荐fork一个多线程的进程的，因为如果存在锁的情况下，会导致锁异常

Binder 机制中存在 Binder 线程池，是多线程的，如果 Zygote 采用 Binder 的话就存在上面说的 fork() 与 多线程的问题了。

其实严格来说，Binder 机制不一定要多线程，所谓的 Binder 线程只不过是在循环读取 Binder 驱动的消息而已，只注册一个 Binder 线程也是可以工作的，比如 service manager 就是这样的。

实际上 Zygote 尽管没有采取 Binder 机制，它也不是单线程的，但它在 fork() 前主动停止了其他线程，fork() 后重新启动了

2、效率问题：AMS和Zygote之间使用的LocalSocket，相对于网络Socket，减少了数据验证等环节，所以其实效率相对于正常的网络Socket会大幅的提升。虽然还是要经过两次拷贝，但是由于数据量并不大，所以其实影响并不明显

3、Binder拷贝问题：如果使用Binder机制的话，从Zygote中fork出子进程会拷贝Zygote中Binder对象。从而多占用了一块无用的内存区域

代码细节请参考：Activity的启动流程分析与总结-云社区-华为云

fork进程哪些内存段可以被继承

1. 代码段（text segment）： 包含可执行程序的指令，子进程会继承父进程的代码段。

2. 数据段（data segment）： 包含已初始化的全局变量和静态变量，子进程会继承父进程的数据段。

3. BSS 段： 包含未初始化的全局变量和静态变量，子进程会继承父进程的 BSS 段，并且该段会被清零。

4. 堆段（heap segment）： 存放动态分配的内存，子进程会继承父进程的堆段，但是堆段中的内存并不会共享，子进程会获得一份独立的堆空间。

而以下内存段不会被继承：

1. 栈段（stack segment）： 存放函数调用的局部变量和函数参数，子进程会获得一个与父进程相同大小的栈空间，但是其中的内容是未定义的。

2. 堆栈顶指针（stack pointer）： 指向栈段的顶部，子进程会获得与父进程相同的堆栈顶指针。