Android App 启动流程、Activity 启动流程及核心系统组件

zygote

本文将结构化拆解 App 启动流程、Activity 启动流程，并详细解析 SystemServer、Zygote、ServiceManager、PowerManagerService 的功能、关系与执行先后顺序。

Android 系统启动流程思维导图

App 启动流程（整体概览）

App 启动是从用户点击图标到主界面显示的完整过程，涉及内核、Zygote、SystemServer 等核心组件，分为 5 个核心阶段：

阶段 1：用户触发启动（Launcher 发送请求）

  1. 用户点击 Launcher 上的 App 图标 → Launcher 进程通过 startActivity() 向 AMS（ActivityManagerService） 发送启动请求。

  2. AMS 检查该 App 是否已运行：

    • 若已运行：直接将后台的 Activity 进程切换到前台。
    • 若未运行：向 Zygote 发送创建新进程的请求。

阶段 2：Zygote 孵化 App 进程

  1. AMS 通过 socket 向 Zygote 进程发送创建进程的指令（携带 App 的包名、UID 等信息）。

  2. Zygote 进程执行 fork() 系统调用，基于自身进程孵化出 App 的独立进程（子进程）。

    • Zygote 是所有 App 进程的「父进程」，自身由 init 进程启动，且启动时已加载 Android 核心类库、初始化虚拟机。
    • fork() 采用写时复制机制，大幅降低新进程的创建开销。

  3. 新进程启动后，初始化 ActivityThread（App 进程的主线程），并通过 Binder 向 AMS 报告进程已创建。

阶段 3：ActivityThread 初始化应用

  1. ActivityThread 创建 ApplicationThread（Binder 线程，负责与 AMS 跨进程通信）和 H（Handler，负责线程切换，将 Binder 线程的消息转发到主线程）。
  2. 调用 attach() 方法，通过 ApplicationThread 向 AMS 注册 App 进程。
  3. AMS 向 App 进程发送启动主 Activity 的指令。

阶段 4：Application 与 Activity 初始化

  1. ActivityThread 接收到指令后，通过 H 将任务切换到主线程。

  2. 创建 Application 实例：

    • 调用 attachBaseContext() → 调用 onCreate()（开发者在此初始化全局资源）。

  3. 创建主 Activity 实例：

    • 执行 onCreate() → onStart() → onResume() 生命周期方法。

  4. 执行 View 渲染流程：measure → layout → draw，最终通过 SurfaceFlinger 合成显示到屏幕。

阶段 5：AMS 完成状态管理

AMS 记录 App 进程、Activity 的运行状态，将其加入任务栈，完成整个启动流程。

Activity 启动流程（详细拆解）

Activity 启动是 App 启动的核心子流程，跨进程通信是核心特点，分为 6 步（以启动新 Activity 为例）：

  1. 应用层发起请求：当前 Activity 调用 startActivity(Intent) → 最终调用 Instrumentation.execStartActivity()。

  2. Binder 跨进程调用 AMS：Instrumentation 通过 Binder 向 SystemServer 进程的 AMS 发送启动请求。

  3. AMS 权限与栈管理：

    • AMS 检查权限、验证 Intent 合法性；
    • 根据 launchMode 决定创建新实例或复用已有实例；
    • 向 Zygote 请求创建进程（若进程未启动）。

  4. AMS 通知 App 进程创建 Activity：

    • AMS 通过 Binder 向 App 进程的 ApplicationThread 发送创建 Activity 的指令。

  5. 线程切换与 Activity 实例化：

    • ApplicationThread 接收到指令后，通过 H（Handler） 将任务转发到主线程（ActivityThread）；
    • ActivityThread 通过 ClassLoader 创建 Activity 实例；
    • 依次调用 onCreate() → onStart() → onResume()。

  6. AMS 同步状态：Activity 生命周期执行完成后，ApplicationThread 向 AMS 报告状态，AMS 更新任务栈信息。

核心系统组件详解

1. Zygote（孵化器进程）

核心功能

  • 进程孵化器：是 Android 系统中所有 App 进程和 SystemServer 进程的父进程，由 init 进程启动（解析 init.rc 配置文件）。
  • 预加载资源：启动时会预加载 Android 核心类库、系统资源（如主题、字符串）、初始化 Dalvik/ART 虚拟机，避免每个 App 进程重复初始化，提升进程创建速度。
  • 进程创建：通过 fork() 系统调用创建子进程（App 进程或 SystemServer 进程），采用写时复制机制，减少内存开销。

关键特点

  • 自身是一个特殊的 Dalvik/ART 进程，不执行具体业务逻辑，仅负责孵化进程。
  • 通过 socket 与 SystemServer 通信，接收创建进程的请求。

2. ServiceManager（系统服务管家）

核心功能

  • 系统服务注册中心：是 Android 系统的「Binder 大管家」，负责管理所有系统服务的注册与查询。
  • 服务注册：所有系统服务（如 AMS、WMS、PMS）启动后，都会向 ServiceManager 注册（通过 addService() 方法）。
  • 服务查询：客户端（如 App 进程）需要使用系统服务时，通过 getService() 向 ServiceManager 查询，获取服务的 Binder 代理对象。

关键特点

  • 由 init 进程启动，是第一个启动的系统服务，运行在 SystemServer 进程启动前。
  • 自身不提供业务服务，仅负责「服务的注册与转发」。

3. SystemServer（系统服务进程）

核心功能

  • 系统服务的宿主进程：是 Android 系统的「核心服务容器」，几乎所有核心系统服务都运行在该进程中（如 AMS、WMS、PMS、PowerManagerService 等）。
  • 启动与管理系统服务：由 Zygote 进程 fork() 生成，启动后会依次启动各类系统服务，并将服务注册到 ServiceManager。
  • 系统核心调度：协调各系统服务之间的通信，是 App 进程与系统服务交互的「中转站」。

启动的核心服务分类

服务类型代表服务核心作用
生命周期管理AMS（ActivityManagerService）管理 Activity 生命周期、进程调度
窗口管理WMS（WindowManagerService）管理窗口的显示、层级、大小
包管理PMS（PackageManagerService）管理 App 安装、卸载、权限
电源管理PowerManagerService管理设备电源状态、休眠 / 唤醒

4. PowerManagerService（电源管理服务）

核心功能

  • 设备电源状态管理：是 Android 系统中负责电源策略、休眠唤醒、亮度调节的核心服务，运行在 SystemServer 进程。

  • 核心职责：

    1. 监听电源键、电池状态、传感器事件（如距离传感器）；
    2. 管理设备状态（开机、休眠、唤醒、关机）；
    3. 调节屏幕亮度、控制背光开关；
    4. 实现电源节能策略（如屏幕自动熄灭、进程休眠）。

  • 对外接口：通过 PowerManager 类向应用层提供 API（如唤醒屏幕、设置屏幕亮度）。

核心组件的关系与执行先后顺序

1. 组件之间的依赖关系

init 进程 → ServiceManager → Zygote → SystemServer → 各类系统服务（含 PowerManagerService）→ App 进程
  • init 是根进程：Android 系统启动后，内核首先启动 init 进程，它是所有进程的祖先。
  • ServiceManager 是服务管家：由 init 启动，为后续系统服务提供注册 / 查询能力。
  • Zygote 是孵化器：由 init 启动，负责孵化 SystemServer 和所有 App 进程。
  • SystemServer 是服务容器：由 Zygote 孵化，启动并管理 PowerManagerService 等所有系统服务，且将服务注册到 ServiceManager。
  • PowerManagerService 是子服务：运行在 SystemServer 进程内部，依赖 SystemServer 提供的运行环境，同时通过 ServiceManager 对外提供服务。

2. 严格的执行先后顺序（系统启动阶段）

系统启动时，组件的启动顺序是固定且不可逆的，具体步骤如下：

  1. 内核启动：Android 设备开机后，首先加载内核，初始化硬件驱动。

  2. 启动 init 进程：内核启动后，启动 init 进程，init 解析 init.rc 配置文件。

  3. 启动 ServiceManager：init 进程根据配置启动 ServiceManager，使其进入等待状态，准备接收服务注册请求。

  4. 启动 Zygote 进程：init 进程启动 Zygote 进程，Zygote 预加载核心类库和资源，初始化虚拟机，监听 socket 端口。

  5. Zygote 孵化 SystemServer 进程：

    • Zygote 通过 fork() 创建 SystemServer 进程；
    • SystemServer 进程启动后，初始化主线程，依次启动各类系统服务（包括 PowerManagerService、AMS、WMS 等）。

  6. 系统服务注册到 ServiceManager：每个系统服务启动后，都会调用 ServiceManager.addService() 完成注册。

  7. PowerManagerService 启动：作为 SystemServer 启动的服务之一，启动后注册到 ServiceManager，开始管理设备电源状态。

  8. 启动 Launcher 进程：SystemServer 启动完成后，AMS 会启动 Launcher 进程（桌面应用），用户可点击图标启动 App。

  9. Zygote 孵化 App 进程：用户启动 App 时，AMS 通过 socket 通知 Zygote，Zygote fork() 生成 App 进程。

3. 组件协作示例（App 启动时）

当用户启动 App 时，核心组件的协作流程：

用户点击 Launcher → Launcher 通过 ServiceManager 获取 AMS 代理 → AMS 通过 socket 通知 Zygote → Zygote fork App 进程 → App 进程通过 ServiceManager 获取 PowerManagerService 代理（若需电源相关操作）

总结

  1. App 启动流程：用户触发 → AMS 请求 → Zygote 孵化进程 → ActivityThread 初始化 → Application 与 Activity 启动 → 界面显示。
  2. Activity 启动流程：应用层请求 → Binder 调用 AMS → AMS 管理栈与进程 → App 进程线程切换 → Activity 实例化与生命周期执行。
  3. 核心组件关系：init 是根进程，ServiceManager 是服务管家，Zygote 是进程孵化器，SystemServer 是服务容器，PowerManagerService 是 SystemServer 内的子服务。
  4. 执行先后：init → ServiceManager → Zygote → SystemServer → PowerManagerService → App 进程。
最近更新：:
Contributors: luokaiwen