Android Activity启动流程详解

Android Activity 启动流程是一个涉及多个系统组件（Launcher、SystemServer、AMS、Zygote、目标进程）和跨进程通信（Binder）的复杂过程。以下是详细流程分析，结合关键源码（基于最新稳定版源码）：

核心参与者

  1. Launcher进程：用户交互起点
  2. SystemServer进程：托管AMS等核心服务
  3. Zygote进程：孵化应用进程
  4. 目标应用进程：运行待启动Activity

详细启动流程

1. Launcher发起请求

  • 用户点击App图标，触发Launcher的startActivitySafely()
  • 调用Activity.startActivityForResult()
  • 最终通过Instrumentation.execStartActivity()发起跨进程调用

关键源码：

java

// Launcher3源码: src/com/android/launcher3/Launcher.java
public boolean startActivitySafely(View v, Intent intent, ...) {
    // 关键Flag：强制创建新任务栈
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
    
    // 通过ActivityClientController发起
    return startActivity(v, intent, opts);
}

// 调用链：Activity.java
public void startActivity(Intent intent, ...) {
    mInstrumentation.execStartActivity(
        this, mMainThread.getApplicationThread(),  // 传递ApplicationThread代理
        mToken, intent, requestCode, options);
}

// Instrumentation.java核心IPC跳转
public ActivityResult execStartActivity(...) {
    // 获取ActivityTaskManagerService的Binder代理
    int result = ActivityTaskManager.getService().startActivity(
        whoThread, who.getBasePackageName(), intent, ...);
    
    // 检查启动结果（如ActivityNotFound）
    checkStartActivityResult(result, intent);
}

2. 请求到达AMS（跨进程Binder调用）

  • Instrumentation通过Binder调用ActivityManagerService.startActivity()

  • AMS进行关键校验：

    • 权限检查
    • Intent解析（resolveIntent()）
    • Activity是否存在（PackageManager.resolveActivity()）

关键流程：

java

// ActivityManagerService.java
public final int startActivity(...) {
    return startActivityAsUser(...); // 多用户支持
}

3. AMS处理启动请求

  • 进程检查：通过ProcessRecord判断目标进程是否存在

  • 进程不存在：触发startProcessLocked()

    • 通过socket通知Zygote孵化新进程
    • 新进程入口：ActivityThread.main()

进程创建源码：

java

// ActivityManagerService.java
final ProcessRecord startProcessLocked(...) {
    // 构造启动参数
    final String entryPoint = "android.app.ActivityThread";
    
    // 通过ZygoteProcess发起fork请求
    Process.ProcessStartResult startResult = Process.start(entryPoint,
        app.processName, uid, ...);
    
    // 保存进程记录
    mProcessNames.put(app.processName, app.uid, app);
}

// ZygoteProcess.java - 建立Socket连接
public static ProcessStartResult start(...) {
    return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), args);
}

4. Zygote孵化新进程

  • Zygote收到fork请求，调用Zygote.forkAndSpecialize()

  • 新进程执行ActivityThread.main()：

    • 初始化MainLooper
    • 创建ActivityThread实例
    • 调用attach(false)绑定到AMS

进程入口：

java

// ActivityThread.java
// ActivityThread.java (frameworks/base/core/java/android/app/)
public static void main(String[] args) {
    // 初始化主线程Looper
    Looper.prepareMainLooper(); 
    
    // 创建主线程实例
    ActivityThread thread = new ActivityThread();
    
    // 绑定到系统服务
    thread.attach(false, startSeq);
    
    // 启动消息循环
    Looper.loop();
}

private void attach(boolean system, long startSeq) {
    // 获取IActivityManager代理
    final IActivityManager mgr = ActivityManager.getService();
    
    // 关键IPC：向AMS注册ApplicationThread
    mgr.attachApplication(mAppThread, startSeq);
}

5. 应用进程绑定到AMS

  • 通过Binder调用AMS.attachApplication()
  • AMS发送BIND_APPLICATION消息到应用主线程
  • 创建Application对象并调用onCreate()

绑定流程：

java

// ActivityManagerService.java
public void attachApplication(IApplicationThread thread, long startSeq) {
    synchronized (this) {
        // 绑定死亡监听器
        thread.asBinder().linkToDeath(new AppDeathRecipient(...));
        
        // 触发应用初始化
        attachApplicationLocked(thread, callingPid, startSeq);
    }
}

private boolean attachApplicationLocked(...) {
    // 1. 创建Application对象
    thread.bindApplication(processName, appInfo, ...);
    
    // 2. 启动所有待启动Activity
    mAtmInternal.attachApplication(app);
}

// ActivityTaskManagerInternal实现
public boolean attachApplication(ProcessRecord app) {
    // 遍历所有需要启动的ActivityRecord
    for (int i = mRootWindowContainer.getChildCount() - 1; i >= 0; --i) {
        final ActivityRecord r = stack.topRunningActivity();
        if (r.app == null && app.mState.getCurProc() == app) {
            // 触发Activity启动
            stack.startActivityLocked(r, ...);
        }
    }
}

6. AMS触发Activity启动

  • AMS调用ApplicationThread.scheduleLaunchActivity()
    （ApplicationThread是ActivityThread的内部类）
  • 发送LAUNCH_ACTIVITY消息到主线程H（Handler）

源码路径：

java

// ActivityThread.java - ApplicationThread
public void scheduleLaunchActivity(...) {
    sendMessage(H.LAUNCH_ACTIVITY, r);
}

7. 主线程处理启动

  • H.handleMessage()处理LAUNCH_ACTIVITY

  • 调用handleLaunchActivity()：

    • 创建Activity：mInstrumentation.newActivity()
    • 创建Context：createBaseContext()
    • 调用onCreate()：activity.performCreate()
    • 触发onStart/onResume：ActivityThread.performResumeActivity()

核心代码：

java

// ActivityThread.java
// ActivityThread.java - H类（Handler）
public void handleMessage(Message msg) {
    switch (msg.what) {
        case LAUNCH_ACTIVITY:
            handleLaunchActivity((ActivityClientRecord) msg.obj);
            break;
        case RESUME_ACTIVITY:
            handleResumeActivity(...);
            break;
    }
}

private void handleLaunchActivity(ActivityClientRecord r) {
    // 1. 创建Activity实例
    Activity activity = performLaunchActivity(r, customIntent);
    
    // 2. 执行onCreate()
    if (activity != null) {
        handleResumeActivity(r.token, ...);
    }
}

private Activity performLaunchActivity(...) {
    // 反射创建Activity实例
    java.lang.ClassLoader cl = appContext.getClassLoader();
    activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
    
    // 创建Application（若未创建）
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
    // 关联Context
    Context appContext = createBaseContextForActivity(r);
    activity.attach(appContext, ...);
    
    // 调用onCreate()
    mInstrumentation.callActivityOnCreate(activity, r.state);
    
    return activity;
}

窗口创建时序

// ActivityThread.handleResumeActivity()
final void handleResumeActivity(...) {
    // 调用onResume()
    performResumeActivity(token, ...);
    
    // 获取窗口管理器
    ViewManager wm = activity.getWindowManager();
    
    // 添加DecorView
    wm.addView(decor, layoutParams);
}

// WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params) {
    // 创建ViewRootImpl
    ViewRootImpl root = new ViewRootImpl(view.getContext(), display);
    
    // 关联视图
    root.setView(view, wparams, panelParentView);
}

// ViewRootImpl.java
public void setView(View view, ...) {
    // 请求布局
    requestLayout();
    
    // IPC: 通过WindowManagerService添加窗口
    mWindowSession.addToDisplayAsUser(...);
}

关键时序图

图表

deepseek_mermaid_20250729_f35a76.png

技术难点解析

  1. 跨进程通信：全程涉及4次Binder调用+1次Socket通信
  2. 主线程同步：所有生命周期方法通过Handler切换到主线程
  3. 窗口管理：onResume()后通过WindowManager.addView()触发UI绘制
  4. ANR监控：AMS从startActivity开始计时（默认10s）

📌 重要提示：冷启动耗时从startActivity()到首帧绘制（包含onCreate/onStart/onResume），热启动则跳过进程创建。

优化方向

  1. 减少onCreate()耗时：避免主线程阻塞操作
  2. 预加载：利用splash screen API（Android 12+）
  3. 延迟初始化：使用App Startup库或ViewModel懒加载
  4. 类预加载：通过MultiDex优化或Profile-Guided Optimization

理解此流程对解决启动黑屏、ANR、跨进程通信等问题至关重要。

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容