Activity启动原理

# 04.Activity启动原理

# 目录介绍

一、引言：Activity的核心地位
二、Activity启动的全链路分析
- 2.1 启动流程概览
- 2.2 startActivity的源码入口
- 2.3 Instrumentation：Activity的"经纪人"
三、AMS调度Activity的核心逻辑
- 3.1 ATMS的启动调度
- 3.2 ActivityStarter：启动逻辑的核心
- 3.3 Task与ActivityRecord的管理
四、进程创建与Application初始化
- 4.1 目标进程不存在时的创建流程
- 4.2 Application的创建时序
五、Activity对象的创建过程
- 5.1 realStartActivityLocked：真正的启动
- 5.2 ClientTransaction的执行
- 5.3 performLaunchActivity：创建Activity实例
六、生命周期的底层驱动机制
- 6.1 TransactionExecutor与生命周期状态机
- 6.2 生命周期切换的执行
- 6.3 两个Activity切换时的生命周期顺序
七、Activity的生命周期状态机
- 7.1 完整状态转换图
- 7.2 各生命周期方法的系统含义
八、onSaveInstanceState与状态恢复
- 8.1 状态保存的触发时机
- 8.2 状态保存的底层实现
- 8.3 配置变更与Activity重建
九、Activity的启动模式原理
- 9.1 四种启动模式
- 9.2 启动模式在AMS中的处理
- 9.3 Intent Flags与启动模式的组合
十、TaskRecord与Back Stack管理
- 10.1 Task的数据结构
- 10.2 Back Stack的管理
十一、Activity的窗口创建与关联
- 11.1 Activity与Window的关系
- 11.2 Window添加到WMS的时机
十二、Activity的销毁与内存回收
- 12.1 主动销毁（finish）
- 12.2 系统回收（LMK/OOM）
十三、面试高频问题与深度分析
- 13.1 Activity A启动Activity B，两者的生命周期调用顺序？
- 13.2 横竖屏切换时生命周期怎么走？
- 13.3 如何让Activity不被系统回收后重建时丢失数据？
十四、Activity详细启动源码流程
- 14.1 Launcher启动Activity流程
- 14.2 startActivity完整流程
- 14.3 Activity创建详细过程
- 14.4 Activity启动模式详解
- 14.5 Task任务栈设计
- 14.6 Activity启动流程总结
十五、总结

# 一、引言：Activity的核心地位

Activity是Android四大组件中最重要的一个，它代表了一个用户可以交互的"屏幕"。理解Activity的启动流程和生命周期管理，需要深入AMS（ActivityManagerService）、ActivityThread、Instrumentation等核心类的源码。

疑惑：为什么简单的startActivity(intent)背后需要这么复杂的流程？为什么生命周期方法的调用顺序是固定的？

本文将从源码级别拆解Activity启动的每一步，揭示生命周期管理的底层机制。

# 二、Activity启动的全链路分析

# 2.1 启动流程概览

startActivity() 的完整调用链：

App进程                          system_server进程               Zygote进程
│                                │                              │
│ Activity.startActivity()       │                              │
│   → Instrumentation            │                              │
│     .execStartActivity()       │                              │
│       → ATMS.startActivity()   │                              │
│         ────Binder IPC────→   │                              │
│                                │ ATMS.startActivityAsUser()   │
│                                │   → startActivityUnchecked() │
│                                │   → 检查权限、解析Intent      │
│                                │   → 查找或创建Task           │
│                                │   → 目标进程是否存在？        │
│                                │     ├── 存在 → 调度Activity  │
│                                │     └── 不存在 → 创建进程    │
│                                │       → AMS.startProcess()   │
│                                │         ────Socket────→     │ fork()
│                                │                              │ → 新进程
│                                │                              │
│ ←────Binder回调────────────── │                              │
│ ActivityThread                 │                              │
│   .handleLaunchActivity()      │                              │
│   → performLaunchActivity()    │                              │
│     → Instrumentation          │                              │
│       .newActivity()           │                              │
│     → activity.attach()        │                              │
│     → activity.onCreate()      │                              │
│   → handleResumeActivity()     │                              │
│     → activity.onResume()      │                              │
│     → WindowManager.addView()  │                              │

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

# 2.2 startActivity的源码入口

// Activity.java
public void startActivity(Intent intent) {
    startActivity(intent, null);
}

public void startActivity(Intent intent, Bundle options) {
    startActivityForResult(intent, -1, options);
}

public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
    // Instrumentation是Activity操作的实际执行者
    Instrumentation.ActivityResult ar =
        mInstrumentation.execStartActivity(
            this, mMainThread.getApplicationThread(),  // IApplicationThread
            mToken,  // Activity在AMS中的标识
            this, intent, requestCode, options);
    
    if (ar != null) {
        // 发送结果给调用方
        mMainThread.sendActivityResult(mToken, mEmbeddedID, requestCode,
                ar.getResultCode(), ar.getResultData());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 2.3 Instrumentation：Activity的"经纪人"

// Instrumentation.java
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token,
        Activity target, Intent intent, int requestCode, Bundle options) {
    
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    
    // 通知ActivityMonitor（用于测试）
    // ...
    
    try {
        intent.migrateExtraStreamToClipData(who);
        intent.prepareToLeaveProcess(who);
        
        // 跨进程调用AMS
        int result = ActivityTaskManager.getService()
            .startActivity(whoThread, who.getOpPackageName(),
                who.getAttributionTag(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()),
                token, target != null ? target.mEmbeddedID : null,
                requestCode, 0, null, options);
        
        // 检查启动结果
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    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

# 三、AMS调度Activity的核心逻辑

# 3.1 ATMS的启动调度

// ActivityTaskManagerService.java (Android 10+从AMS拆分)
int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo,
        String resultWho, int requestCode, int startFlags,
        ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
    
    // 1. 权限检查
    enforceNotIsolatedCaller("startActivity");
    userId = handleIncomingUser(callingPid, callingUid, userId, "startActivity");
    
    // 2. 创建ActivityStarter并执行
    return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            .setCallingPackage(callingPackage)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setActivityOptions(bOptions)
            .execute();  // 执行启动逻辑
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 3.2 ActivityStarter：启动逻辑的核心

// ActivityStarter.java
int execute() {
    // 1. 解析Intent，确定目标Activity
    resolveActivity();
    // 通过PMS解析Intent → 找到目标ActivityInfo
    
    // 2. 检查各种启动条件
    int result = executeRequest(mRequest);
    return result;
}

private int executeRequest(Request request) {
    // 关键检查：
    // a. 权限检查（调用者是否有权启动目标Activity）
    // b. 组件是否可用（是否enabled，是否exported）
    // c. 是否被拦截（AppOps、DevicePolicyManager等）
    
    // 创建ActivityRecord（Activity在AMS中的表示）
    final ActivityRecord r = new ActivityRecord.Builder(mService)
        .setIntent(intent)
        .setActivityInfo(aInfo)
        .setResultTo(resultRecord)
        .build();
    
    // 进入启动事务
    startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
            startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
}

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

# 3.3 Task与ActivityRecord的管理

AMS中Activity的组织结构（Android 12+）：

RootWindowContainer
  └── TaskDisplayArea
        └── Task (Root Task，原ActivityStack)
              └── Task (Leaf Task，原TaskRecord)
                    ├── ActivityRecord (Activity A)
                    ├── ActivityRecord (Activity B)  ← 栈顶
                    └── ActivityRecord (Activity C)

// ActivityRecord是Activity在AMS中的"替身"
class ActivityRecord {
    ActivityInfo info;          // Activity的配置信息
    Intent intent;              // 启动它的Intent
    Task task;                  // 所在的Task
    IBinder appToken;           // Activity的Binder令牌
    ProcessRecord app;          // 所在进程
    ActivityState mState;       // 当前状态(CREATED/STARTED/RESUMED/...)
    Bundle icicle;              // 保存的状态
    boolean finishing;          // 是否正在finish
    boolean stopped;            // 是否已停止
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 四、进程创建与Application初始化

# 4.1 目标进程不存在时的创建流程

// 当目标Activity所在进程不存在时
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
    final WindowProcessController wpc = mService.getProcessController(
            r.processName, r.info.applicationInfo.uid);
    
    if (wpc != null && wpc.hasThread()) {
        // 进程已存在，直接调度
        realStartActivityLocked(r, wpc, andResume, checkConfig);
        return;
    }
    
    // 进程不存在，请求创建
    mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}

// 最终走到：
// AMS → Process.start() → ZygoteProcess → Socket → Zygote → fork()
// → ActivityThread.main() → AMS.attachApplication()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 4.2 Application的创建时序

// ActivityThread.java → handleBindApplication()
private void handleBindApplication(AppBindData data) {
    // 1. 创建LoadedApk（APK加载信息）
    data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
    
    // 2. 创建Instrumentation
    mInstrumentation = new Instrumentation();
    
    // 3. 创建Application对象
    Application app = data.info.makeApplication(false, mInstrumentation);
    // 内部通过反射创建：
    // Class<?> clazz = Class.forName(className);
    // Application app = (Application) clazz.newInstance();
    // app.attach(context);
    
    mInitialApplication = app;
    
    // 4. 安装ContentProviders（在Application.onCreate之前！）
    installContentProviders(app, data.providers);
    
    // 5. 调用Application.onCreate()
    mInstrumentation.callApplicationOnCreate(app);
}

// 注意调用顺序：
// Application构造函数 → attachBaseContext() → ContentProvider.onCreate() → Application.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

# 五、Activity对象的创建过程

# 5.1 realStartActivityLocked：真正的启动

// ActivityTaskSupervisor.java
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
        boolean andResume, boolean checkConfig) {
    
    // 构造ClientTransaction（生命周期事务）
    final ClientTransaction clientTransaction = ClientTransaction.obtain(
            proc.getThread(), r.token);
    
    // 添加LaunchActivityItem回调
    clientTransaction.addCallback(LaunchActivityItem.obtain(
            new Intent(r.intent), System.identityHashCode(r),
            r.info, mergedConfiguration,
            r.getFilteredReferrer(r.launchedFromPackage), ...));
    
    // 设置最终生命周期状态
    if (andResume) {
        clientTransaction.setLifecycleStateRequest(
                ResumeActivityItem.obtain(isTransitionForward));
    } else {
        clientTransaction.setLifecycleStateRequest(
                PauseActivityItem.obtain());
    }
    
    // 发送事务到App进程
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    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

# 5.2 ClientTransaction的执行

// TransactionExecutor.java（App进程中执行）
public void execute(ClientTransaction transaction) {
    // 1. 执行回调（如LaunchActivityItem）
    executeCallbacks(transaction);
    
    // 2. 执行生命周期状态切换
    executeLifecycleState(transaction);
}

// LaunchActivityItem.java
public void execute(ClientTransactionHandler client, IBinder token, ...) {
    // 调用ActivityThread.handleLaunchActivity()
    ActivityClientRecord r = new ActivityClientRecord(token, mIntent, ...);
    client.handleLaunchActivity(r, pendingActions, null);
}

// ActivityThread.java
public Activity handleLaunchActivity(ActivityClientRecord r, ...) {
    // 核心：创建Activity并调用onCreate
    final Activity a = performLaunchActivity(r, customIntent);
    return a;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 5.3 performLaunchActivity：创建Activity实例

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 1. 获取ActivityInfo
    ActivityInfo aInfo = r.activityInfo;
    
    // 2. 创建Context
    ContextImpl appContext = createBaseContextForActivity(r);
    
    // 3. 通过反射创建Activity实例
    Activity activity = mInstrumentation.newActivity(
            cl, component.getClassName(), r.intent);
    // 内部：Class.forName(className).newInstance()
    
    // 4. 创建Application（如果还没创建）
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
    // 5. attach：关联Window、Context等
    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, ...);
    // attach内部：
    //   mWindow = new PhoneWindow(this, window, ...);  // 创建PhoneWindow
    //   mWindow.setWindowManager(wm, token, ...);       // 关联WindowManager
    //   mToken = token;                                  // 保存AMS令牌
    
    // 6. 调用onCreate
    if (r.isPersistable()) {
        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
    } else {
        mInstrumentation.callActivityOnCreate(activity, r.state);
    }
    // 内部：activity.performCreate(icicle)
    //       → activity.onCreate(icicle)
    
    r.activity = activity;
    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

# 六、生命周期的底层驱动机制

# 6.1 TransactionExecutor与生命周期状态机

// Android 9+引入的生命周期管理：ClientLifecycleManager + TransactionExecutor

// 生命周期状态定义
public static final int UNDEFINED = -1;
public static final int PRE_ON_CREATE = 0;
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public static final int ON_PAUSE = 4;
public static final int ON_STOP = 5;
public static final int ON_DESTROY = 6;
public static final int ON_RESTART = 7;

// 状态切换路径
private static int[] getLifecyclePath(int start, int finish) {
    // 例如：从ON_CREATE到ON_RESUME
    // 路径：ON_CREATE → ON_START → ON_RESUME
    // 返回：[ON_START, ON_RESUME]
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 6.2 生命周期切换的执行

// TransactionExecutor.java
private void executeLifecycleState(ClientTransaction transaction) {
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    final int path = cycleToPath(activity, lifecycleItem.getTargetState(), ...);
    
    // 按路径逐步执行生命周期方法
    performLifecycleSequence(r, path, transaction);
}

private void performLifecycleSequence(ActivityClientRecord r, IntArray path, ...) {
    for (int i = 0; i < size; i++) {
        final int state = path.get(i);
        switch (state) {
            case ON_CREATE:
                mTransactionHandler.handleLaunchActivity(r, ...);
                break;
            case ON_START:
                mTransactionHandler.handleStartActivity(r, ...);
                break;
            case ON_RESUME:
                mTransactionHandler.handleResumeActivity(r, ...);
                break;
            case ON_PAUSE:
                mTransactionHandler.handlePauseActivity(r, ...);
                break;
            case ON_STOP:
                mTransactionHandler.handleStopActivity(r, ...);
                break;
            case ON_DESTROY:
                mTransactionHandler.handleDestroyActivity(r, ...);
                break;
            case ON_RESTART:
                mTransactionHandler.performRestartActivity(r, ...);
                break;
        }
    }
}

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

# 6.3 两个Activity切换时的生命周期顺序

Activity A → 启动 Activity B：

A.onPause()          ← AMS先暂停当前Activity
  ↓
B.onCreate()         ← 创建新Activity
  ↓
B.onStart()
  ↓
B.onResume()         ← 新Activity获得焦点
  ↓
A.onStop()           ← 旧Activity不可见后才stop
                       （通过IdleHandler延迟执行）

为什么A.onPause()先于B.onCreate()？
→ AMS的设计：必须先暂停当前Activity，确保系统状态一致
→ 如果A.onPause()耗时太长，会延迟B的启动

为什么A.onStop()最后执行？
→ B完全显示后A才真正不可见
→ A.onStop()通过StopActivityItem延迟执行
→ 如果10秒内A还没stop，AMS会强制stop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 七、Activity的生命周期状态机

# 7.1 完整状态转换图

                    ┌──────────────┐
                    │  不存在       │
                    └──────┬───────┘
                           │ startActivity()
                    ┌──────↓───────┐
            ┌──────→│  onCreate()  │←────────┐
            │       └──────┬───────┘         │
            │              │                  │
            │       ┌──────↓───────┐         │
            │       │  onStart()   │←─┐      │
            │       └──────┬───────┘  │      │
            │              │          │      │
            │       ┌──────↓───────┐  │      │
            │       │  onResume()  │  │      │
            │       └──────┬───────┘  │      │
            │              │          │      │
            │       [Activity运行中]    │      │
            │              │          │      │
            │       ┌──────↓───────┐  │      │
            │       │  onPause()   │  │      │
            │       └──────┬───────┘  │      │
            │              │          │      │
            │       ┌──────↓───────┐  │      │
            │       │  onStop()    │──┘      │
            │       └──────┬───────┘         │
            │              │ onRestart()     │
            │       ┌──────↓───────┐         │
            │       │  onDestroy() │         │
            │       └──────┬───────┘         │
            │              │                  │
            │       ┌──────↓───────┐         │
            └───────│  不存在       │─────────┘
                    │ （系统杀死后） │ 用户返回时重建
                    └──────────────┘

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

# 7.2 各生命周期方法的系统含义

onCreate()   → Activity被创建，初始化View和数据
               对应AMS状态：CREATED
               系统操作：attach Window、创建DecorView

onStart()    → Activity对用户可见（但可能不在前台）
               对应AMS状态：STARTED  
               系统操作：注册广播接收器等

onResume()   → Activity在前台且可交互
               对应AMS状态：RESUMED
               系统操作：开始绘制、注册传感器等

onPause()    → Activity失去焦点（但可能仍可见，如Dialog覆盖）
               对应AMS状态：PAUSED
               系统操作：提交数据库事务、释放独占资源
               关键约束：必须快速完成（否则影响下一个Activity启动）

onStop()     → Activity完全不可见
               对应AMS状态：STOPPED
               系统操作：释放不可见资源、保存状态
               特殊：通过IdleHandler延迟执行

onDestroy()  → Activity即将销毁
               对应AMS状态：DESTROYING → DESTROYED
               系统操作：释放所有资源、取消注册

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

# 八、onSaveInstanceState与状态恢复

# 8.1 状态保存的触发时机

onSaveInstanceState()的调用时机：
1. 按Home键回到桌面
2. 按最近任务键
3. 启动新Activity
4. 屏幕旋转
5. 系统内存不足杀死后台Activity

不调用的情况：
1. 用户主动按Back键退出
2. 调用finish()

调用时序（Android P+）：
onPause() → onStop() → onSaveInstanceState()
// P之前是在onPause之后、onStop之前

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

# 8.2 状态保存的底层实现

// ActivityThread.java → callActivityOnSaveInstanceState
final void performSaveInstanceState(Bundle outState) {
    onSaveInstanceState(outState);
    // 保存Fragment状态
    mFragments.saveAllState();
    
    // View层级自动保存（需要设置android:id）
    // Window.saveHierarchyState() 
    //   → DecorView遍历所有子View
    //   → 调用每个View.onSaveInstanceState()
    //   → 以View的ID为key保存到Bundle
    
    outState.putParcelable(WINDOW_HIERARCHY_TAG, windowState);
}

// 状态保存在AMS中：
// ActivityRecord.icicle = savedInstanceState
// 当Activity被系统杀死后重建时，这个Bundle会传给onCreate(savedInstanceState)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 8.3 配置变更与Activity重建

屏幕旋转时的完整流程：

1. 系统检测到Configuration变更
2. AMS调用handleRelaunchActivity()
3. 执行序列：
   onPause()
   onStop()
   onSaveInstanceState(outState)
   onDestroy()
   ← 旧Activity销毁 →
   onCreate(savedInstanceState)  ← savedInstanceState非空
   onStart()
   onRestoreInstanceState(savedInstanceState)
   onResume()

阻止重建（在AndroidManifest中配置）：
android:configChanges="orientation|screenSize|keyboardHidden"
→ 系统不重建Activity，改为调用onConfigurationChanged()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 九、Activity的启动模式原理

# 9.1 四种启动模式

┌──────────────┬─────────────────────────────────────────────┐
│  启动模式      │  行为                                       │
├──────────────┼─────────────────────────────────────────────┤
│  standard     │  每次创建新实例，加入当前Task栈顶              │
│              │  同一个Activity可以创建多个实例                │
├──────────────┼─────────────────────────────────────────────┤
│  singleTop   │  栈顶复用：如果目标已在栈顶，不创建新实例       │
│              │  而是调用onNewIntent()                        │
│              │  不在栈顶则创建新实例                          │
├──────────────┼─────────────────────────────────────────────┤
│  singleTask  │  栈内复用：在目标Task中查找，已存在则复用       │
│              │  清除其上方所有Activity（clearTop效果）         │
│              │  不存在则创建新实例                            │
├──────────────┼─────────────────────────────────────────────┤
│  singleInstance│ 独占Task：单独占有一个Task                  │
│              │  该Task中只有这一个Activity实例                │
│              │  全局唯一实例                                 │
└──────────────┴─────────────────────────────────────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 9.2 启动模式在AMS中的处理

// ActivityStarter.java → startActivityUnchecked()
private int startActivityUnchecked(...) {
    // 根据launchMode和Intent flags计算启动行为
    computeLaunchingTaskFlags();
    computeSourceRootTask();
    
    // singleTop检查
    if (mLaunchMode == LAUNCH_SINGLE_TOP || 
        (mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0) {
        final ActivityRecord top = mTargetRootTask.topRunningActivity();
        if (top != null && top.mActivityComponent.equals(mStartActivity.mActivityComponent)) {
            // 栈顶是同一个Activity → 复用，调用onNewIntent
            deliverNewIntent(top, mStartActivity.intent);
            return START_DELIVERED_TO_TOP;
        }
    }
    
    // singleTask检查
    if (mLaunchMode == LAUNCH_SINGLE_TASK) {
        // 在所有Task中查找目标Activity
        ActivityRecord existing = findActivityInHistory(mStartActivity);
        if (existing != null) {
            // 找到了 → 把它所在的Task移到前台，清除其上方Activity
            existing.getTask().moveToFront("startActivity");
            existing.getTask().performClearTop(mStartActivity, mLaunchFlags);
            deliverNewIntent(existing, mStartActivity.intent);
            return START_TASK_TO_FRONT;
        }
    }
    
    // 创建新实例
    setNewTask();  // 或加入现有Task
    addActivityToTask(mStartActivity, mTargetRootTask);
}

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

# 9.3 Intent Flags与启动模式的组合

常用Intent Flags：

FLAG_ACTIVITY_NEW_TASK
  → 在新Task中启动（类似singleTask，但不清除栈）
  → 从非Activity Context启动Activity时必须加

FLAG_ACTIVITY_CLEAR_TOP
  → 清除目标Activity上方的所有Activity
  → 配合singleTask使用效果更好

FLAG_ACTIVITY_SINGLE_TOP
  → 等效于singleTop启动模式

FLAG_ACTIVITY_CLEAR_TASK
  → 清除整个Task，必须配合NEW_TASK使用
  → 相当于finish掉Task中所有Activity后再创建新的

组合示例：
NEW_TASK + CLEAR_TASK → 完全重新开始（常用于登出后跳转登录页）
NEW_TASK + CLEAR_TOP → 类似singleTask效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 十、TaskRecord与Back Stack管理

# 10.1 Task的数据结构

Task的组织（Android 12+使用Window Hierarchy）：

DisplayContent
  └── TaskDisplayArea ("DefaultTaskDisplayArea")
        ├── Task (Root Task - Fullscreen)
        │     ├── Task (Leaf - App1的任务栈)
        │     │     ├── ActivityRecord (MainActivity)
        │     │     └── ActivityRecord (DetailActivity)
        │     └── Task (Leaf - App2的任务栈)
        │           └── ActivityRecord (HomeActivity)
        ├── Task (Root Task - Freeform)
        └── Task (Root Task - PiP)

1
2
3
4
5
6
7
8
9
10
11
12

# 10.2 Back Stack的管理

Back Stack的行为：

用户操作序列：
1. 打开App → Task:[A]
2. A启动B  → Task:[A, B]
3. B启动C  → Task:[A, B, C]  ← 栈顶C显示
4. 按Back   → Task:[A, B]     ← C被销毁
5. 按Back   → Task:[A]        ← B被销毁
6. 按Back   → Task:[]         ← A被销毁，Task销毁

按Home键：
Task:[A, B, C] → 整个Task移到后台
再次打开App → Task:[A, B, C] 恢复，C在栈顶

跨Task启动（singleTask）：
Task1:[A, B]  Task2:[X, Y]
B启动Y（singleTask）→ Task2移到前台
Task2:[X, Y]  ← Y调用onNewIntent
按Back → Task2:[X]
按Back → Task1:[A, B]  ← 回到原来的Task

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 十一、Activity的窗口创建与关联

# 11.1 Activity与Window的关系

Activity的窗口层级结构：

Activity
  └── PhoneWindow (mWindow)
        └── DecorView (mDecor)
              ├── TitleBar / ActionBar
              └── ContentView (android.R.id.content)
                    └── 用户setContentView的布局

// activity.attach()中创建PhoneWindow
mWindow = new PhoneWindow(this, window, activityConfigCallback);
mWindow.setWindowControllerCallback(mWindowControllerCallback);
mWindow.setCallback(this);  // Activity实现了Window.Callback

// setContentView()
public void setContentView(int layoutResID) {
    getWindow().setContentView(layoutResID);  // 委托给PhoneWindow
}

// PhoneWindow.setContentView()
public void setContentView(int layoutResID) {
    if (mContentParent == null) {
        installDecor();  // 创建DecorView和ContentView
    }
    mLayoutInflater.inflate(layoutResID, mContentParent);
}

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

# 11.2 Window添加到WMS的时机

Window真正添加到屏幕是在onResume()之后：

handleResumeActivity() {
    // 1. 调用onResume
    performResumeActivity(r);
    
    // 2. 将DecorView添加到WindowManager
    if (r.window == null && !a.mFinished) {
        r.window = r.activity.getWindow();
        View decor = r.window.getDecorView();
        decor.setVisibility(View.INVISIBLE);  // 先设为不可见
        
        ViewManager wm = a.getWindowManager();
        WindowManager.LayoutParams l = r.window.getAttributes();
        
        // 关键：addView → 创建ViewRootImpl → 触发View绘制
        wm.addView(decor, l);
        // WindowManagerImpl → WindowManagerGlobal.addView()
        //   → new ViewRootImpl()
        //   → root.setView(decor, wparams, ...)
        //     → requestLayout()  → 触发measure/layout/draw
        //     → mWindowSession.addToDisplayAsUser() → 通知WMS
    }
    
    // 3. 设置DecorView可见
    r.activity.makeVisible();
    // decor.setVisibility(View.VISIBLE);
}

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

# 十二、Activity的销毁与内存回收

# 12.1 主动销毁（finish）

// Activity.finish() → AMS.finishActivity()
public void finish() {
    finish(DONT_FINISH_TASK_WITH_ACTIVITY);
}

// AMS端处理：
boolean finishActivityLocked(ActivityRecord r, int resultCode, Intent resultData, ...) {
    r.makeFinishingLocked();  // 标记finishing=true
    
    // 1. 暂停Activity
    startPausingLocked(false, false, null);
    
    // 2. 暂停完成后 → 停止 → 销毁
    // finishCurrentActivityLocked()
    //   → destroyActivityLocked()
    //     → 发送DestroyActivityItem到App进程
    //     → ActivityThread.handleDestroyActivity()
    //       → performDestroyActivity()
    //         → activity.onDestroy()
    //         → 移除Window
    //         → 清理引用
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 12.2 系统回收（LMK/OOM）

系统内存不足时的回收策略：

进程优先级（从高到低）：
1. 前台进程（正在交互的Activity）       → 几乎不会被杀
2. 可见进程（可见但不在前台的Activity）  → 极少被杀
3. 服务进程（运行着Service的进程）       → 内存紧张时可能被杀
4. 缓存进程（后台Activity，已stop）      → 按LRU顺序优先被杀
5. 空进程（无任何活动组件）              → 最先被杀

LMK（Low Memory Killer）的工作：
/sys/module/lowmemorykiller/parameters/minfree
→ 定义不同优先级的内存阈值
→ 当可用内存低于阈值时，杀死对应优先级的进程

进程被杀后：
→ AMS中的ActivityRecord仍保留
→ 用户返回时，AMS发现进程不存在
→ 重新fork进程 → 重新创建Activity
→ 传入之前保存的savedInstanceState
→ 用户几乎无感知

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 十三、面试高频问题与深度分析

# 13.1 Activity A启动Activity B，两者的生命周期调用顺序？

精确顺序：
A.onPause()
B.onCreate()
B.onStart()
B.onResume()
A.onStop()           ← 在B可见后才调用
A.onSaveInstanceState() ← 在onStop之后（Android P+）

如果B是透明的（Theme.Translucent）：
A.onPause()
B.onCreate()
B.onStart()
B.onResume()
// A.onStop()不调用！因为A仍然可见

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

# 13.2 横竖屏切换时生命周期怎么走？

未配置configChanges：
onPause → onStop → onSaveInstanceState → onDestroy
→ onCreate(bundle) → onStart → onRestoreInstanceState → onResume

配置了configChanges="orientation|screenSize"：
onConfigurationChanged()  // 只调用这一个

注意：Android 3.2+ 必须同时配置orientation和screenSize

1
2
3
4
5
6
7
8

# 13.3 如何让Activity不被系统回收后重建时丢失数据？

三种方案：

1. onSaveInstanceState / onRestoreInstanceState
   → 适合轻量级UI状态（滚动位置、输入文本等）
   → Bundle有大小限制（约1MB）

2. ViewModel
   → 配置变更时不销毁（屏幕旋转等）
   → 适合大量数据和异步操作
   → 进程被杀时仍会丢失

3. SavedStateHandle（配合ViewModel）
   → ViewModel + onSaveInstanceState的结合
   → 进程被杀时也能恢复

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

# 十四、Activity详细启动源码流程

# 14.1 Launcher启动Activity流程

Launcher启动Activity的入口是LauncherActivity#onListItemClick()，通过隐式Intent启动目标Activity（因为跨进程无法直接引用目标Activity字节码）。

应用图标与Launcher Activity的关联：系统启动时PackageManagerService会解析所有应用的AndroidManifest.xml，为包含<intent-filter>中MAIN和LAUNCHER信息的Activity创建快捷图标。

用户点击桌面图标的完整流程：

1. Launcher捕获点击事件
   Launcher3中的ItemClickHandler.onClick(View v)
   → 获取图标绑定的ItemInfo（包含ComponentName和Intent）
   → startActivitySafely(v, intent, itemInfo)
   → intent.addFlags(FLAG_ACTIVITY_NEW_TASK)
   → startActivity(intent, optsBundle)

2. Intent的构造
   Launcher为每个桌面图标缓存了Intent信息：
   ├── ComponentName = 包名/Activity全类名
   ├── Action = Intent.ACTION_MAIN
   ├── Category = Intent.CATEGORY_LAUNCHER
   └── 来源：PMS启动时扫描所有Manifest的解析结果

3. 跨进程调用AMS
   Launcher进程                    system_server
       │ startActivity(intent)        │
       │ → Instrumentation            │
       │   .execStartActivity()       │
       │ ────Binder IPC──→           │ ATMS.startActivity()
       │                              │ → 权限检查
       │                              │ → 解析Intent，PMS匹配目标Activity
       │                              │ → 创建ActivityRecord
       │                              │ → 判断目标进程是否存在
       │                              │ → fork进程 / 直接调度
       │ onPause() ←──Binder──       │ → 先暂停Launcher

4. 冷启动 vs 热启动 vs 温启动
   冷启动：进程不存在 → fork + Application.onCreate + Activity = 较慢
   热启动：进程和Activity都在 → 直接onRestart/onResume = 最快
   温启动：进程在但Activity被回收 → 重建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

# 14.2 startActivity完整流程

startActivity完整调用链：

1. 发起请求阶段
MyActivity.startActivity()
→ Activity.startActivity()
→ Activity.startActivityForResult()  // requestCode>=0时onActivityResult才回调
→ Instrumentation.execStartActivity() // 协调启动、权限检查
→ ActivityManagerNative.getDefault().startActivityAsUser()

2. AMS处理阶段
→ AMS.startActivityAsUser()
→ ActivityStackSupervisor.startActivityMayWait()
→ ActivityStackSupervisor.startActivityLocked()
→ ActivityStackSupervisor.startActivityUncheckedLocked()
→ ActivityStackSupervisor.resumeTopActivitiesLocked()

3. 暂停栈顶Activity
→ ActivityStack.startPausingLocked()
→ IApplicationThread.schedulePauseActivity()
→ ActivityThread.handlePauseActivity()
→ Activity.onPause()
→ AMS.activityPaused()

4. 创建并启动目标Activity
→ ActivityStackSupervisor.realStartActivityLocked()
→ IApplicationThread.scheduleLauncherActivity()
→ ActivityThread.handleLauncherActivity()
→ ActivityThread.performLauncherActivity()
    ├── mInstrumentation.newActivity()  // 反射创建Activity
    ├── activity.attach()               // 创建PhoneWindow
    └── mInstrumentation.callActivityOnCreate()
        └── Activity.onCreate()

5. Activity可见阶段
→ ActivityThread.handleResumeActivity()
→ ActivityThread.performResumeActivity()
→ Activity.onResume()

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

# 14.3 Activity创建详细过程

ActivityThread.performLaunchActivity()中创建Activity的关键步骤：

创建Activity上下文：通过createBaseContextForActivity()创建ContextImpl对象
反射创建Activity：通过mInstrumentation.newActivity()，ClassLoader加载Activity类并调用newInstance()
Activity.attach()：创建PhoneWindow对象，设置窗口回调接口，关联ContextImpl
执行onCreate：通过mInstrumentation.callActivityOnCreate()回调Activity.onCreate()

# 14.4 Activity启动模式详解

Activity设计不同启动模式是为了满足不同的需求和场景：

启动模式	行为	适用场景
standard	每次创建新实例	独立的界面
singleTop	栈顶复用，调用onNewIntent	通知栏点击启动
singleTask	栈内复用，清除上方Activity	主界面
singleInstance	独立任务栈，全局唯一	来电页面、设置界面

特殊情况：在Service或Application中启动Activity时，需要使用FLAG_ACTIVITY_NEW_TASK标记位创建新的任务栈。

# 14.5 Task任务栈设计

Task是一个Activity栈，通常用户感受的一个Application就是一个Task。Task只针对Activity，与Service等组件没有关系。

关键设计：

taskAffinity属性：默认一个应用只有一个栈（以包名为标识），可以通过taskAffinity为Activity指定不同的栈
affinity应用场景：根据affinity重新为Activity选择宿主task；使用FLAG_ACTIVITY_NEW_TASK时根据affinity查找或创建新task

# 14.6 Activity启动流程总结

Activity启动通过startActivity或startActivityForResult开始，内部都是调用startActivityForResult
启动流程涉及多个进程间通讯，主要是ActivityThread与AMS之间的通讯
AMS接收请求后执行初始化、解析启动模式、保存请求信息等操作
AMS会先让当前栈顶Activity执行onPause，然后判断目标应用进程是否已启动
若进程未启动，AMS通过Socket与Zygote通信，fork新进程并执行ActivityThread.main()
最终通过反射创建Activity对象，依次执行onCreate、onStart、onResume
Activity的启动模式、Task管理和窗口关联是整个流程中的核心设计

# 十五、总结

Activity启动与生命周期管理是Android Framework中最复杂的子系统之一：

Activity核心知识图谱：

启动流程
├── Instrumentation → AMS入口
├── ATMS → 权限检查、Task管理
├── ActivityStarter → 启动模式处理
├── ClientTransaction → 生命周期事务
└── ActivityThread → Activity创建与生命周期回调

生命周期
├── 状态机模型 → CREATED/STARTED/RESUMED/PAUSED/STOPPED/DESTROYED
├── TransactionExecutor → 自动路径计算
├── 状态保存与恢复 → onSaveInstanceState/onRestoreInstanceState
└── 配置变更处理 → 重建或onConfigurationChanged

Task管理
├── Back Stack → 后进先出
├── 启动模式 → standard/singleTop/singleTask/singleInstance
├── Intent Flags → NEW_TASK/CLEAR_TOP/SINGLE_TOP/CLEAR_TASK
└── taskAffinity → Task归属

窗口关联
├── PhoneWindow → DecorView → ContentView
├── ViewRootImpl → View绘制入口
└── WMS → 窗口在屏幕上的显示

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

上次更新: 2026/06/10, 11:13:41

← Handler消息机制四大组件原理分析→