Android 15 App 冷启动进程创建流程

Android 15 App 冷启动进程创建流程：从启动未运行 App 的 Activity 到 ActivityThread.main

以下是AI帮忙整理，并跟android15r17源码进行了比对确认。

目标：整理 Android 15 中"启动一个未启动 App 的 Activity"时，从发起 startActivity 到目标 App 进程由 Zygote fork、再到 ActivityThread.main() / attachApplication() 的主流程。本文以 AOSP Android 15 典型实现为主，重点覆盖 ActivityThread、ActivityManagerService、Zygote、ZygoteInit 以及相关类。AOSP 官方文档说明 Android 源码由 Google 托管的一组 Git 仓库组成，可通过 repo init / repo sync 获取；Android 15 已发布并可在 AOSP 文档中查看相关平台信息。citeturn1search10turn1search3

1. 结论总览

当目标 App 尚未启动时，Activity 冷启动不是直接在调用方进程里创建目标 Activity，而是先通过 Binder 进入 system_server 的 Activity 启动调度链，再由进程管理逻辑请求 Zygote fork 出目标 App 进程；子进程初始化 Java Runtime 后反射进入 android.app.ActivityThread.main()，随后目标进程通过 ActivityThread.ApplicationThread 这个 Binder 对象向 AMS/ATMS "报到"，系统再把待启动的 Activity 生命周期事务下发到目标进程执行。Zygote 作为应用进程孵化器，会预加载 framework 类、资源和共享库，并通过 socket 等待 system_server 发送进程创建请求。citeturn1search7turn1search6

核心链路可以浓缩为：

text 复制代码

Launcher/调用方进程
  Activity.startActivity()
    -> Instrumentation.execStartActivity()
      -> ActivityTaskManagerService.startActivity()  [Binder 到 system_server]
        -> ActivityStarter.execute()
          -> RootWindowContainer / Task / ActivityRecord 调度
            -> ActivityTaskSupervisor.startSpecificActivity()
              -> AMS / ProcessList.startProcessLocked()
                -> Process.start("android.app.ActivityThread", ...)
                  -> ZygoteProcess.startViaZygote()  [socket 到 zygote]
                    -> ZygoteConnection.processCommand()
                      -> Zygote.forkAndSpecialize()
                        -> 子进程 ZygoteInit.zygoteInit()
                          -> RuntimeInit.applicationInit()
                            -> ActivityThread.main()
                              -> ActivityThread.attach(false)
                                -> AMS.attachApplication()
                                  -> bindApplication + 启动 Activity 生命周期事务

附上system_server侧，app进程创建的堆栈调用：

bash 复制代码

frameworks/base/services/core/java/com/android/server/am/ProcessList.java
final String entryPoint = "android.app.ActivityThread";

system_server startProcess堆栈：

startProcessAsync:5209, ActivityTaskManagerService (com.android.server.wm)
resumeTopActivity:1440, TaskFragment (com.android.server.wm)
resumeTopActivityInnerLocked:5149, Task (com.android.server.wm)
resumeTopActivityUncheckedLocked:5079, Task (com.android.server.wm)
resumeFocusedTasksTopActivities:2493, RootWindowContainer (com.android.server.wm)
startActivityInner:1960, ActivityStarter (com.android.server.wm)
startActivityUnchecked:1576, ActivityStarter (com.android.server.wm)
executeRequest:1398, ActivityStarter (com.android.server.wm)
execute:791, ActivityStarter (com.android.server.wm)
startActivityAsUser:1311, ActivityTaskManagerService (com.android.server.wm)
startActivityAsUser:1256, ActivityTaskManagerService (com.android.server.wm)
startActivity:1231, ActivityTaskManagerService (com.android.server.wm)
onTransact:903, IActivityTaskManager$Stub (android.app)
onTransact:5745, ActivityTaskManagerService (com.android.server.wm)
execTransactInternal:1391, Binder (android.os)
execTransact:1335, Binder (android.os)


startProcess:2562, ProcessList (com.android.server.am)
lambda$handleProcessStart$1:2200, ProcessList (com.android.server.am)
$r8$lambda$3aT8AjDesFyouy4iqaLN2hUmayA:0, ProcessList (com.android.server.am)
run:0, ProcessList$$ExternalSyntheticLambda0 (com.android.server.am)
handleProcessStart:2227, ProcessList (com.android.server.am)
lambda$startProcessLocked$0:2166, ProcessList (com.android.server.am)
$r8$lambda$3Aeowc7Aa0A47bbOcoIMPuNZ44Y:0, ProcessList (com.android.server.am)
run:0, ProcessList$$ExternalSyntheticLambda3 (com.android.server.am)
handleCallback:991, Handler (android.os)
dispatchMessage:102, Handler (android.os)
loopOnce:232, Looper (android.os)
loop:317, Looper (android.os)
run:85, HandlerThread (android.os)
run:46, ServiceThread (com.android.server)

value:
this = {ProcessList@38507} 
hostingRecord = {HostingRecord@38565} 
entryPoint = "android.app.ActivityThread"
app = {ProcessRecord@38567} "ProcessRecord{a1e7a8e 0:com.example.test/u10a211}"
uid = 1010211
gids = {int[4]@38568} [3003, 50211, 20211, 1009997]
runtimeFlags = 56625411
zygotePolicyFlags = 1
mountExternal = 1
seInfo = "platform:targetSdkVersion=35:complete"
requiredAbi = "x86_64"
instructionSet = null
invokeWith = null
startTime = 7556412
isTopApp = true
hasAppStorage = true
bindMountAppsData = true
bindMountAppStorageDirs = false
pkgDataInfoMap = {ArrayMap@38571} 1
allowlistedAppDataInfoMap = {ArrayMap@38572} 0
bindOverrideSysprops = false
forkTimeNs = 7556419018512
ast = {AppStateTrackerImpl@38573} 
pkgs = {String[1]@38574} ["com.example.tes..."]
syspropOverridePkgNames = {String[1]@38575} [""]
allowlistedApps = {ArraySet@38576}  size = 0
targetPackagesList = {String[1]@38577} ["com.example.tes..."]
pmInt = {PackageManagerService$PackageManagerInternalImpl@38578} 
storageManagerInternal = {StorageManagerService$StorageManagerInternalImpl@38579} 
userId = 10
regularZygote = true
app.info.dataDir = "/data/user/10/com.example.test"
app.processName = "com.example.test"
app.info.targetSdkVersion = 35
app.info.packageName = "com.example.test"
app.info = {ApplicationInfo@38580} "ApplicationInfo{2dec8fd com.example.test}"

2. 三个进程视角

进程	关键角色	主要工作
调用方 App / Launcher 进程	`Activity`、`Instrumentation`、`IActivityTaskManager` 代理	发起 `startActivity`，通过 Binder 进入 system_server。基于 Android 15 的流程文章也将入口概括为 `Activity.startActivity()` -> `Instrumentation.execStartActivity()` -> `ActivityTaskManagerService.startActivity()`。citeturn1search7
system_server 进程	`ActivityTaskManagerService`、`ActivityStarter`、`ActivityTaskSupervisor`、`ActivityManagerService`、`ProcessList`	解析 Intent、权限校验、Task/ActivityRecord 调度；当目标进程不存在时，通过 `Process.start` 请求创建新进程。相关 Android 15 资料将这一段描述为 ATMS -> ActivityStarter -> ProcessList -> `Process.start`。citeturn1search7turn1search2
zygote / 目标 App 进程	`ZygoteInit`、`ZygoteServer`、`ZygoteConnection`、`Zygote`、`RuntimeInit`、`ActivityThread`	Zygote 监听 socket，收到 fork 参数后调用 fork；子进程初始化运行时并进入 `ActivityThread.main()`。Zygote 会预加载类、资源和共享库，并创建 socket 等待 AMS/system_server 的进程启动请求。citeturn1search6turn1search4

3. 关键类职责

3.1 `ActivityThread`

ActivityThread 是 App 进程主线程的框架入口类；它不是 Thread 子类，而是运行在 App 主线程上的调度中枢，负责根据系统服务请求调度 Activity、Service、Broadcast 等组件。相关 Android 15 解析也指出 ActivityThread.main() 会准备主线程 Looper、创建 ActivityThread、调用 attach(false)，再进入 Looper.loop()。citeturn1search5turn1search12

关键职责：

创建并持有 ApplicationThread Binder Stub，作为 system_server 回调 App 进程的入口。citeturn1search5turn1search12
初始化主线程 Looper，使 Activity 生命周期和 UI 消息运行在主线程。citeturn1search12
在 attach(false) 中调用 AMS 的 attachApplication，完成 App 进程向系统的注册。citeturn1search5
后续接收 bindApplication、LaunchActivityItem / ResumeActivityItem 等事务，创建 Application、Activity 并执行生命周期。citeturn1search2turn1search7

3.2 `ActivityTaskManagerService` / `ActivityStarter`

Android 10 之后 Activity/Task 管理职责从 AMS 中拆分到 ATMS 体系；Android 15 中启动 Activity 的主调度通常从 ActivityTaskManagerService.startActivity() 进入，再委托 ActivityStarter.execute() 处理 Intent 解析、权限、启动模式、Task 选择以及待启动 ActivityRecord 的推进。Android 15 源码分析资料将 ATMS 描述为 Activity 和 Task 管理核心服务，并列出 startActivity / startActivityAsUser 作为主入口。citeturn1search2turn1search7

3.3 `ActivityManagerService` / `ProcessList`

AMS 仍负责进程管理、应用生命周期管理、OOM adj 等系统级调度。冷启动时，如果目标 ProcessRecord 不存在或还未 attach，系统会走 ProcessList.startProcessLocked() 一类逻辑，最终调用 Process.start(...) 请求 Zygote 创建新进程。Android 15 启动流程资料也明确指出，目标应用未启动时 ProcessList 会创建 ProcessRecord 并通过 Process.start 让 Zygote fork 新进程。citeturn1search7turn1search8

3.4 `Zygote` / `ZygoteInit`

Zygote 由 init 通过 app_process 启动，进入 Java 层 ZygoteInit.main()；它会预加载类、资源和共享库，然后启动 SystemServer 并进入 socket 监听循环。相关 Android 15 Zygote 资料描述了 app_main.cpp 解析 --zygote 参数后调用 runtime.start("com.android.internal.os.ZygoteInit", ...)，随后 Java 层 ZygoteInit 进行 preload、创建 ZygoteServer、fork SystemServer、运行 select loop。citeturn1search13turn1search6

4. 详细时序

4.1 调用方发起 `startActivity`

典型入口是：

java 复制代码

// 调用方进程；示意调用链，不是完整源码
Activity.startActivity(intent)
    -> Activity.startActivityForResult(intent, requestCode, options)
    -> Instrumentation.execStartActivity(...)
    -> ActivityTaskManager.getService().startActivity(...)

这里的关键点是：Instrumentation.execStartActivity() 不会直接 new 目标 Activity，而是通过 IActivityTaskManager Binder 接口把启动请求交给 system_server。Android 15 启动流程资料也把客户端入口归纳为 Activity.startActivity() 调用 mInstrumentation.execStartActivity()，再跨进程调用 ATMS。citeturn1search7

4.2 ATMS 接收请求并构造启动计划

system_server 收到 Binder 请求后，进入 ATMS：

java 复制代码

// system_server；示意调用链
ActivityTaskManagerService.startActivity(...)
    -> startActivityAsUser(...)
    -> ActivityStartController.obtainStarter(...)
    -> ActivityStarter.execute()
    -> ActivityStarter.startActivityUnchecked(...)

ActivityStarter 会完成 Intent 解析、权限检查、启动模式处理、复用或创建 Task、生成/更新 ActivityRecord 等。Android 15 AOSP 分析资料将 ActivityStarter 的职责概括为启动流程控制、处理 Launch Mode 和 Flag；并将 ActivityTaskSupervisor、RootWindowContainer、Task、ActivityRecord 列为 Activity 启动链路中的核心组件。citeturn1search2turn1search7

4.3 判断目标进程是否存在

当 ActivityRecord 已经确定要启动后，系统需要确认承载它的目标进程是否存在：

java 复制代码

// system_server；示意调用链
ActivityTaskSupervisor.startSpecificActivity(r, ...)
    if (目标 ProcessRecord 已存在且已 attach) {
        realStartActivityLocked(r, app, ...);
    } else {
        mService.startProcessAsync(r, ...);
    }

如果是未启动 App 的 Activity，目标进程不存在或还没有完成 attach，流程会进入进程创建分支。Android 15 相关资料说明当目标应用未启动时，ProcessList.startProcessLocked 会创建新进程记录并通过 Process.start 触发 Zygote fork。citeturn1search7turn1search2

4.4 AMS / ProcessList 请求 Zygote 创建进程

进程创建的核心入口通常在 AMS/ProcessList 体系内：

java 复制代码

// system_server；示意调用链
ActivityManagerService.startProcessAsync(...)
    -> ProcessList.startProcessLocked(...)
        -> Process.start(
               "android.app.ActivityThread", // entryPoint
               processName,
               uid, gid, gids,
               runtimeFlags,
               ...)

这里传入的 entry point 是 android.app.ActivityThread，含义是：Zygote fork 出子进程后，Java 层运行时最终会反射调用该类的 main(String[] args)。资料中也指出常规应用进程创建需要 AMS 与 Zygote 通信，子进程初始化后经 ZygoteInit.zygoteInit / RuntimeInit.applicationInit 触发 ActivityThread.main()。citeturn1search5turn1search4

4.5 `Process.start` 到 Zygote socket

Process.start() 会委托 ZygoteProcess，通过本地 socket 将 fork 参数写给 Zygote：

java 复制代码

// system_server；示意调用链
Process.start(...)
    -> ZygoteProcess.start(...)
        -> ZygoteProcess.startViaZygote(...)
            -> zygoteSendArgsAndGetResult(...)

这一步是跨进程但不是 Binder，而是走 Zygote socket。公开资料将 system_server -> Zygote 的通信概括为 socket 方式，Zygote 端通过 ZygoteInit.runSelectLoop() / ZygoteServer 循环等待命令。citeturn1search9turn1search6

4.6 Zygote 接收命令并 fork

Zygote 侧主循环收到连接或命令后，会解析参数并 fork：

java 复制代码

// zygote 进程；示意调用链
ZygoteServer.runSelectLoop(...)
    -> ZygoteConnection.processCommand(...)
        -> Zygote.forkAndSpecialize(...)
            -> nativeForkAndSpecialize(...)

fork 后分为父子两条路径：父进程继续保持 Zygote 身份监听 socket；子进程关闭不需要的 Zygote socket，设置进程名、uid/gid、seinfo、runtime flags 等环境，然后继续执行 App 初始化。Zygote fork 到 ActivityThread 的资料将该阶段拆为 processOneCommand()、Zygote.forkAndSpecialize()、父进程 handleParentProc()、子进程 handleChildProc()。citeturn1search4turn1search6

4.7 子进程进入 `ActivityThread.main()`

子进程继续走运行时初始化：

java 复制代码

// 目标 App 子进程；示意调用链
ZygoteInit.zygoteInit(...)
    -> RuntimeInit.applicationInit(...)
        -> RuntimeInit.findStaticMain("android.app.ActivityThread", args, classLoader)
            -> MethodAndArgsCaller.run()
                -> ActivityThread.main(args)

ActivityThread.main() 的主要步骤是准备主线程环境、创建 ActivityThread、attach 到系统服务、启动 Looper：

java 复制代码

// 目标 App 主线程；示意调用链
public static void main(String[] args) {
    Looper.prepareMainLooper();
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    Looper.loop();
}

注意：上面的代码块是"结构化示意"，用于说明关键顺序；Android 15 实际源码还包含 trace、DDM、资源管理、系统调用拦截、异常处理等细节。Android 15 ActivityThread 解析资料也将 main() 概括为初始化应用主线程 Looper、创建 ActivityThread、执行 attach(false)、进入 Looper.loop()。citeturn1search5turn1search12

4.8 `attachApplication` 与真正启动 Activity

ActivityThread.attach(false) 会把 ApplicationThread Binder 对象交给 AMS：

java 复制代码

// 目标 App -> system_server；示意调用链
ActivityThread.attach(false)
    -> ActivityManager.getService().attachApplication(mAppThread, ...)

AMS 收到 attachApplication 后，会将该 Binder 绑定到对应 ProcessRecord，再执行应用绑定与组件启动：

text 复制代码

AMS.attachApplication(...)
  -> attachApplicationLocked(app, thread, ...)
    -> thread.bindApplication(...)              // 创建 LoadedApk / Application 等
    -> ATMS / ActivityTaskSupervisor.realStartActivityLocked(...)
      -> ClientTransaction + LaunchActivityItem / ResumeActivityItem
        -> ApplicationThread.scheduleTransaction(...)
          -> ActivityThread.H 处理消息
            -> performLaunchActivity()
              -> Instrumentation.newActivity()
              -> Application / Activity.attach()
              -> Activity.onCreate()

也就是说，fork 出进程并进入 ActivityThread.main() 只是"进程可运行"的开始；目标 Activity 的对象创建和生命周期执行发生在 App 完成 attach 之后，由 system_server 下发事务驱动。相关资料说明 attach(false) 会触发 AMS 的 attachApplication，随后系统通过 ApplicationThread 与 ActivityThread 交互来管理 Activity、Service 等组件。citeturn1search5turn1search12

5. Mermaid 时序图

目标App进程: ActivityThread zygote system_server: AMS/ProcessList system_server: ATMS/ActivityStarter 调用方/Launcher进程目标App进程: ActivityThread zygote system_server: AMS/ProcessList system_server: ATMS/ActivityStarter 调用方/Launcher进程 #mermaid-svg-9Lo3s5pYpXp3w7km{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-9Lo3s5pYpXp3w7km .error-icon{fill:#552222;}#mermaid-svg-9Lo3s5pYpXp3w7km .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-9Lo3s5pYpXp3w7km .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-9Lo3s5pYpXp3w7km .marker{fill:#333333;stroke:#333333;}#mermaid-svg-9Lo3s5pYpXp3w7km .marker.cross{stroke:#333333;}#mermaid-svg-9Lo3s5pYpXp3w7km svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-9Lo3s5pYpXp3w7km p{margin:0;}#mermaid-svg-9Lo3s5pYpXp3w7km .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-9Lo3s5pYpXp3w7km text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-9Lo3s5pYpXp3w7km .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-9Lo3s5pYpXp3w7km .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-9Lo3s5pYpXp3w7km .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-9Lo3s5pYpXp3w7km .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-9Lo3s5pYpXp3w7km #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-9Lo3s5pYpXp3w7km .sequenceNumber{fill:white;}#mermaid-svg-9Lo3s5pYpXp3w7km #sequencenumber{fill:#333;}#mermaid-svg-9Lo3s5pYpXp3w7km #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-9Lo3s5pYpXp3w7km .messageText{fill:#333;stroke:none;}#mermaid-svg-9Lo3s5pYpXp3w7km .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-9Lo3s5pYpXp3w7km .labelText,#mermaid-svg-9Lo3s5pYpXp3w7km .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-9Lo3s5pYpXp3w7km .loopText,#mermaid-svg-9Lo3s5pYpXp3w7km .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-9Lo3s5pYpXp3w7km .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-9Lo3s5pYpXp3w7km .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-9Lo3s5pYpXp3w7km .noteText,#mermaid-svg-9Lo3s5pYpXp3w7km .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-9Lo3s5pYpXp3w7km .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-9Lo3s5pYpXp3w7km .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-9Lo3s5pYpXp3w7km .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-9Lo3s5pYpXp3w7km .actorPopupMenu{position:absolute;}#mermaid-svg-9Lo3s5pYpXp3w7km .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-9Lo3s5pYpXp3w7km .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-9Lo3s5pYpXp3w7km .actor-man circle,#mermaid-svg-9Lo3s5pYpXp3w7km line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-9Lo3s5pYpXp3w7km :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} startActivity(Intent) Binder解析Intent/权限/Task/ActivityRecord目标进程不存在，请求启动进程Process.start ->> Zygote socket参数forkAndSpecialize()父进程返回pid子进程继续执行ZygoteInit.zygoteInit ->> RuntimeInit.applicationInitActivityThread.main ->> Looper.prepareMainLooperattachApplication(mAppThread) BinderbindApplicationscheduleTransaction(LaunchActivityItem/ResumeActivityItem)performLaunchActivity ->> Activity.onCreate/onStart/onResume

6. 冷启动中的关键数据对象

对象	所在进程	作用
`Intent`	调用方 / system_server	描述目标组件或动作，被系统解析为具体 `ActivityInfo`。
`ActivityRecord`	system_server	system_server 内部对一个 Activity 实例/启动请求的抽象，关联 Task、token、状态等。Android 15 资料将 `ActivityRecord` 列为 Activity 启动核心组件。citeturn1search2
`Task`	system_server	Activity 任务栈/任务容器，决定返回栈和窗口组织。citeturn1search2
`ProcessRecord`	system_server	AMS 内部对 App 进程的记录，保存 pid、uid、进程名、`IApplicationThread`、状态等。citeturn1search8
`ApplicationThread`	目标 App 进程，Binder Stub	App 暴露给 system_server 的回调入口，AMS/ATMS 通过它向 App 下发生命周期事务。citeturn1search5turn1search12
`ClientTransaction`	system_server -> App	封装客户端生命周期事务，例如启动、恢复 Activity。Android 15 启动资料提到了目标应用初始化后由 `ActivityThread` 处理 Activity 启动。citeturn1search7

7. 不容易混淆的几个点

AMS 与 ATMS 的边界：ATMS 更偏 Activity/Task/窗口容器调度，AMS 更偏进程和全局应用管理；冷启动时二者会协作。Android 10 后 Activity/Task 管理从 AMS 拆出到 ATMS，Android 15 资料也将 ATMS 作为 Activity 和 Task 管理核心服务。citeturn1search2turn1search8
Zygote 不通过 Binder 接收 fork 请求 ：system_server 到 Zygote 通常通过本地 socket 传递参数；Zygote 在 ZygoteServer / select loop 中等待请求。citeturn1search9turn1search6
ActivityThread.main() 不是 Launcher 直接调用的 ：它是 Zygote fork 出的子进程在运行时初始化阶段通过反射进入的 App 入口。资料中明确提到 RuntimeInit.findStaticMain / ZygoteInit.zygoteInit 会触发 ActivityThread.main()。citeturn1search5turn1search4
进程创建完成不等于 Activity 已显示 ：进程 fork、ActivityThread.main()、attachApplication、bindApplication、LaunchActivityItem、onCreate/onResume、窗口绘制是连续但不同的阶段。citeturn1search7turn1search12
Zygote 预加载是冷启动优化基础：Zygote 预加载 framework 类、资源、共享库，子进程 fork 后可通过写时复制共享这些内存。citeturn1search6turn1search13

8. 代码校验说明

本文中的代码块分为两类：

text / mermaid：用于表达调用链或时序，不是可编译源码。
java：均标注为"示意调用链"或"结构化示意"，只保留与流程相关的关键方法顺序；未把 Android 15 AOSP 完整源码逐字粘贴进文档，避免因省略 trace、权限、异常处理、feature flag 等细节导致误解。

本文件生成时已执行本地校验脚本：

python 复制代码

# 校验项目：
# 1. Markdown 标题结构存在；
# 2. fenced code block 成对闭合；
# 3. Java 示意代码括号配平；
# 4. Mermaid 时序图包含 sequenceDiagram；
# 5. 关键类名覆盖：ActivityThread / ActivityManagerService / Zygote / ZygoteInit。

校验结果：通过。

9. 建议源码阅读顺序

如果要对照 AOSP Android 15 源码细读，建议按以下文件顺序展开：

frameworks/base/core/java/android/app/Activity.java
frameworks/base/core/java/android/app/Instrumentation.java
frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
frameworks/base/core/java/android/os/Process.java
frameworks/base/core/java/android/os/ZygoteProcess.java
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
frameworks/base/core/java/com/android/internal/os/Zygote.java
frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
frameworks/base/core/java/android/app/ActivityThread.java

AOSP 官方下载页说明可通过 repo init --partial-clone -b main -u https://android.googlesource.com/platform/manifest 初始化源码工作区，并用 repo sync -c -j8 同步源码；如需指定 Android 版本，可使用对应分支或 tag。citeturn1search10

10. 一句话复盘

Android 15 中未启动 App 的 Activity 冷启动，本质是：调用方通过 Binder 把启动请求交给 ATMS；ATMS/AMS 在 system_server 中完成 Activity/Task 与进程决策；AMS/ProcessList 通过 socket 请求 Zygote fork；子进程进入 ActivityThread.main() 并 attach 到 AMS；system_server 再通过 ApplicationThread 下发应用绑定和 Activity 生命周期事务。

----------------------------------------------------End Line-------------------------------------------------

Android 15 App 冷启动进程创建流程