Appearance
Android 启动流程深度解析
目录
- Bootloader 启动
- Kernel 初始化
- Init 进程启动
- Zygote 进程启动
- SystemServer 启动
- Launcher 启动
- App 冷启动/热启动流程
- Activity 启动流程源码分析
- 性能优化点
- 面试考点
1. Bootloader 启动
1.1 Bootloader 概述
Bootloader 是设备开机后运行的第一段软件代码，负责初始化硬件、加载操作系统内核，是连接硬件和软件的关键桥梁。
┌─────────────────────────────────────────────────────────────┐
│ Android Boot Flow │
├─────────────────────────────────────────────────────────────┤
│ │
│ Power On ──→ Bootloader ──→ Kernel ──→ Init │
│ ↓ ↓ ↓ │
│ (硬件初始化) (内核加载) (用户空间) │
│ ↓ ↓ ↓ │
│ 内存检测 设备树解析 系统服务启动 │
│ │
└─────────────────────────────────────────────────────────────┘1.2 Bootloader 的启动阶段
Android 采用多级 Bootloader 设计，以 AArch64 架构为例：
启动流程详细时序图：
┌────────────────────────────────────────────────────────────────────┐
│ Stage 0: BL1 (Reset Handler) │
│ - 复位向量表 │
│ - 初始化 MMU │
│ - 跳转到 BL2 │
└────────────────────────────────────────────────────────────────────┘
↓
┌────────────────────────────────────────────────────────────────────┐
│ Stage 1: BL2 (ATF - ARM Trusted Firmware) │
│ - 初始化安全世界和非安全世界 │
│ - 设置 TrustZone │
│ - 跳转到 BL33 (正常世界) │
└────────────────────────────────────────────────────────────────────┘
↓
┌────────────────────────────────────────────────────────────────────┐
│ Stage 2: BL33 (UEFI / Little) │
│ - 初始化基本硬件（内存、存储、显示） │
│ - 读取分区表 │
│ - 加载 Kernel + DTB │
│ - 传递启动参数 │
│ - 跳转到 Kernel Entry Point │
└────────────────────────────────────────────────────────────────────┘1.3 Little Bootloader 源码分析
Little 是 Android 项目开源的 Bootloader，位于 prebuilts/bootloader/
关键代码解析：
c
// bootloader/little/init.c
// 系统初始化入口
static void early_init(void) {
// 1. 初始化串口通信
uart_init();
// 2. 初始化内存控制器
dram_init();
// 3. 初始化显示控制器
display_init();
}
// 加载内核和 DTB
static int load_kernel(void) {
// 从分区表读取 boot 分区
// 解压 kernel 镜像
// 加载到内存指定位置
return 0;
}
// 启动内核
static void boot_kernel(void) {
// 设置启动参数
// 传递 device tree
// 跳转到内核入口
}1.4 Boot 分区结构
boot.img 结构：
┌─────────────────────────────────────────────────────────────┐
│ Header (1 KB) │
│ ├─ Kernel 地址 │
│ ├─ Ramdisk 地址 │
│ ├─ Second 加载地址 │
│ ├─ ... │
├─────────────────────────────────────────────────────────────┤
│ Kernel (压缩) │
│ - 通常使用 gzip 或 lz4 压缩 │
├─────────────────────────────────────────────────────────────┤
│ Ramdisk (压缩) │
│ - 包含 init 和早期系统初始化脚本 │
├─────────────────────────────────────────────────────────────┤
│ Device Tree (DTB) │
│ - 硬件描述表 │
└─────────────────────────────────────────────────────────────┘使用 mkbootimg 工具查看：
bash
# 反解 boot.img
mkbootimg --unpack boot.img
# 输出目录结构
├── kernel # 解压后的内核
├── ramdisk # 初始 ramdisk
├── dtb # device tree
└── ramdisk/ # 解压后的 ramdisk 内容
├── init # 第一个用户空间进程
├── init.rc # init 配置文件
└── ...2. Kernel 初始化
2.1 Kernel 启动流程
Kernel 启动详细流程：
┌──────────────────────────────────────────────────────────────┐
│ 1. 内核解压 │
│ - 从 boot.img 解压到内存 │
│ - 跳转到内核入口点 │
├──────────────────────────────────────────────────────────────┤
│ 2. 早期初始化 │
│ - 初始化 CPU 寄存器 │
│ - 设置堆栈 │
│ - 内存映射 │
├──────────────────────────────────────────────────────────────┤
│ 3. 内存初始化 │
│ - 内存检测 │
│ - 分配内存页 │
│ - 初始化页表 │
├──────────────────────────────────────────────────────────────┤
│ 4. 设备初始化 │
│ - 初始化时钟 │
│ - 初始化中断控制器 │
│ - 初始化 DMA │
├──────────────────────────────────────────────────────────────┤
│ 5. 驱动加载 │
│ - 注册总线驱动 │
│ - 加载字符设备驱动 │
│ - 加载块设备驱动 │
├──────────────────────────────────────────────────────────────┤
│ 6. 根文件系统挂载 │
│ - 挂载 ramfs │
│ - 执行 init 程序 │
└──────────────────────────────────────────────────────────────┘2.2 内核入口函数源码分析
架构依赖的启动代码 (arch/arm64/kernel/head.S)：
assembly
// arch/arm64/kernel/head.S
// AArch64 架构内核入口
.text
.global __primary_switch
.global __boot_cpu_mode
ENTRY(__primary_switch)
// 1. 初始化二级页表
mov x20, sp
// 2. 保存启动模式
mrs x19, tpidr_el0
// 3. 初始化栈指针
mov sp, x0
// 4. 跳转到 C 代码
bl start_kernel
// 5. 内核异常处理
b .
ENDPROC(__primary_switch)start_kernel() 函数 (init/main.c)：
c
// init/main.c - 内核初始化主入口
asmlinkage void __init start_kernel(void)
{
// 1. 早期内存初始化
setup_arch(&command_line);
// 2. 初始化各种锁
smp_setup_processor_id();
debug_locks_early();
// 3. 内存管理初始化
AGGREGATE_PM();
build_all_zonelists(NULL);
page_reporting_init();
pgdat_resize_init();
// ...
// 4. 初始化各种子系统
init_command_line();
setup_nr_cpu_ids();
setup_per_cpu_areas();
boot_cpu_hotplug_init();
smp_prepare_boot_cpu();
// 5. 初始化调度器
sched_init();
// 6. 初始化内存分配器
memblock_allow_resize();
// ...
// 7. 注册设备驱动
rest_init(); // 创建 idle 任务
// 8. 挂载根文件系统
// ...
}2.3 Device Tree 解析
Device Tree 是 Android 内核了解硬件配置的方式。
示例：device tree 节点
dts
// arch/arm64/boot/dts/qcom/sdm845.dtsi
/ {
model = "Qualcomm SDM845";
compatible = "qcom,sdm845";
cpus {
cluster0 {
cpu@0 {
device_type = "cpu";
compatible = "arm,cortex-a73";
reg = <0x0>;
clock-latency-ns = <0>;
};
cpu@1 {
device_type = "cpu";
compatible = "arm,cortex-a73";
reg = <0x1>;
};
// ...
};
};
memory@0 {
device_type = "memory";
reg = <0x0 0x40000000>;
};
display-subsystem {
mdss_mdp {
compatible = "qcom,mdss-mdp-8x96";
interrupts = <GPI_INTERRUPT 70 0>;
};
};
};2.4 重要驱动加载
Android 特有的驱动模块：
c
// drivers/android/lowmemorykiller.c
// 内存回收机制驱动
static int __init lmk_init(void)
{
// 创建设备节点 /dev/lowmemorykiller
lmk_dev = misc_register(&lmk_misc);
// 初始化内存监控
// ...
return 0;
}
// drivers/android/sync.c
// 同步栅栏机制（用于渲染同步）
int sync_timeline_create(const char *name)
{
struct sync_timeline *obj;
// 创建 timeline 对象
// 用于渲染管线同步
}3. Init 进程启动
3.1 Init 进程概述
Init 是 Android 系统的第一个用户空间进程（PID=1），负责整个系统的初始化。
Init 进程启动流程：
┌─────────────────────────────────────────────────────────────────┐
│ Kernel 启动完成 ──→ 挂载根文件系统 ──→ 执行 init 程序 │
│ ↓ │
│ ┌───────────────────────────────┐ │
│ │ /init │ │
│ │ - 编译自 system/core/init │ │
│ └───────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────┐ │
│ │ 解析 init 配置文件 │ │
│ │ - init.rc │ │
│ │ - init.<board>.rc │ │
│ │ - ueventd.rc │ │
│ └───────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────┐ │
│ │ 启动核心服务 │ │
│ │ - property_service │ │
│ │ - logd │ │
│ │ - ueventd │ │
│ │ - healthd │ │
│ │ - watchdogd │ │
│ └───────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────┐ │
│ │ 启动 Zygote │ │
│ └───────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘3.2 Init 源码分析
Init 主循环 (system/core/init/init.cpp)：
cpp
// system/core/init/init.cpp
int main(int argc, char** argv) {
// 1. 设置初始环境
if (argc != 0 && argv[0] != nullptr) {
setprogname(argv[0]);
}
// 2. 设置默认参数
if (argc > 1) {
setenv("ro.bootargs", argv[1], 1);
}
// 3. 解析内核命令行参数
ParseKmsg();
InitLogging();
// 4. 初始化属性服务
property_init();
// 5. 解析 init 配置文件
std::vector<std::string> filenames = {
"init Hardware.rc",
"init.usb.rc",
"init.console.rc",
// ...
};
// 6. 创建早期服务
// 7. 进入主事件循环
event_loop();
}
// 事件循环
static void event_loop() {
// 处理命令、action 等
while (true) {
// 读取命令
std::string line;
getline(command_pipe, line);
// 执行命令
if (!line.empty()) {
RunAction(line);
}
}
}3.3 Init 配置文件解析
init.rc 文件格式：
ini
# system/core/rootdir/init.rc
# 定义属性
property: ro.init.version=1.0
# 定义服务（早期启动）
service ueventd /system/bin/ueventd
class main
user root
group root
critical
service property /system/bin/property_service
class main
user root
group root
critical
# 定义服务（后期启动）
on init
class_start main
# 设置基本参数
setprop ro.boot.bootloader ${bootloader}
setprop ro.boot.serialno ${serialno}
# 挂载文件系统
mount tmpfs tmpfs /dev tmpmode=0755
# 启动 Zygote
class_start late_init
on late-init
# 启动 Zygote
start zygote
# 等待 Zygote 就绪
wait /dev/socket/zygote
on boot
# 启动 SystemServer
start zygote_init
class_start default3.4 Init 服务生命周期
Init 服务状态机：
┌─────────────────────────────────────────────────────────────┐
│ │
│ ┌──────────┐ 启动命令 ┌──────────┐ │
│ │ disabled │ ──────────→ │ start │ │
│ └──────────┘ └──────────┘ │
│ ↑ | | │
│ │ 服务停止 | 进程创建 │
│ │ v v │
│ ┌──────────┐ 进程退出 ┌──────────┐ │
│ │ dead │ ←────────── │ run │ │
│ └──────────┘ └──────────┘ │
│ ↑ | │
│ │ 超时重启 | 重启命令 │
│ └───────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘3.5 重要初始化动作
system/core/rootdir/init.rc 中的关键部分：
ini
# 设置系统属性
on early-init
# 设置设备类型
setprop ro.bootloader ${bootloader}
# 设置 SELinux 状态
setprop init.selinux ${selinux_state}
# 创建必要目录
mkdir /dev/cpuset 0755 root root
mkdir /dev/cpuset/cpu0 0755 root root
# late-init 阶段
on late-init
# 启动 Zygote 进程
start zygote
# 配置网络
class_start early-init
# 设置环境变量
export PATH /system/bin:/system/xbin
# boot 阶段
on boot
# 启动所有默认服务
class_start default
# 等待 SystemServer 启动完成
wait /dev/socket/sysprop4. Zygote 进程启动
4.1 Zygote 进程概述
Zygote 是 Android 应用进程的前身，通过 fork 机制快速创建新的应用进程。
Zygote 启动与进程创建流程：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ Init 启动 Zygote │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ zygote main.cpp │ │
│ │ - 解析命令行参数 │ │
│ │ - 设置环境变量 │ │
│ │ - 创建套接字 │ │
│ │ - 预加载类 │ │
│ │ - 进入主循环 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ forking 循环 │ │
│ │ while (true) { │ │
│ │ 1. accept 连接 │ │
│ │ 2. 读取启动参数 │ │
│ │ 3. fork 创建子进程 │ │
│ │ 4. 子进程执行启动代码 │ │
│ │ } │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 子进程（应用进程） │ │
│ │ - 加载指定类 │ │
│ │ - 调用 main 方法 │ │
│ └─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘4.2 Zygote 源码分析
Zygote 主入口 (app_process.cpp)：
cpp
// frameworks/base/core/jni/com_android_internal_os_ZygoteInit.cpp
static int registerNativeMethods(JNIEnv* env, const char* className,
JNINativeMethod* gMethods, int numMethods)
{
// 注册 Native 方法
// ...
return JNI_ERR;
}
int main(int argc, char* const argv[]) {
// 1. 解析命令行参数
vector<String16> args;
for (int i = 1; i < argc; i++) {
String16 arg(argv[i], strlen(argv[i]));
args.push_back(arg);
}
// 2. 初始化 Native 桥接
if (zygoteInit(args) != 0) {
return -1;
}
// 3. Java VM 初始化
return runtime->start("main_sdk", mainSdk);
}
static int zygoteInit(const Vector<String16>& args) {
// 设置环境变量
setenv("JAVA_OPTS", "-Xms64m -Xmx64m", 0);
// 创建 Runtime
JavaVMInitArgs vm_args;
vm_args.version = JNI_VERSION_1_6;
vm_args.nOptions = nOptions;
vm_args.options = options;
vm_args.ignoreUnrecognized = false;
// 创建 JVM
if (JniCreateJavaVM(&javaVm, &vm_args) < 0) {
return -1;
}
// 初始化 JNI 环境
JavaVM* vm = javaVm;
JNIEnv* env = nullptr;
if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
return -1;
}
// 设置 JNI 全局引用
return -1;
}ZygoteInit.java 源码分析：
java
// frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static final void main(String[] args) {
// 1. 设置启动时间属性
System.setProperty("abc.shout.zygote.start.time",
Long.toString(System.currentTimeMillis()));
// 2. 初始化 Zygote
try {
// 调用 Native 方法初始化
ZygoteInit.zygoteInit(args);
} catch (RuntimeException e) {
LOG.e("ZygoteInit", "Runtime exception in zygote init", e);
System.exit(1);
}
// 3. 预加载类
preloadedClasses();
// 4. 进入 Zygote 服务循环
if (startServerSocket()) {
// 启动 socket 服务器
// 等待 fork 请求
runSelectLoop();
}
}
// Zygote 服务循环
private static void runSelectLoop() {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
fds.add(mServerSocket.getFileDescriptor());
fdArray = new FileDescriptor[fds.size()];
fds.toArray(fdArray);
while (true) {
try {
// 1. select 等待连接
ArrayList<Socket> sockets = acceptAndLog(fds);
// 2. 处理每个连接
for (int i = 0; i < sockets.size(); i++) {
Socket socket = sockets.get(i);
FileDescriptor[] fdPair = socket.getFDPair();
// 3. fork 创建子进程
int pid = Zygote.forkAndSpecialize(
uid, gid, gids,
debugFlags,
rlimits,
mountExternal,
seLinuxCtx,
fdsToClose,
fdsToIgnore,
fdPairs,
fileDescriptorArray,
uid,
null,
null,
null,
null,
null,
null,
null
);
if (pid == 0) {
// 子进程继续执行
zygoteInit(fdPair[0], fdPair[1]);
} else if (pid > 0) {
// 父进程关闭子进程连接
socket.close();
}
}
} catch (IOException e) {
// 处理异常
}
}
}4.3 预加载机制
ZygotePreload.java：
java
// frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
private static native void preloadedClasses() {
// Native 实现的预加载
}
private static void preLoadClasses() {
// 预加载常用类
preloadClass("java.lang.String");
preloadClass("java.util.ArrayList");
preloadClass("android.content.ContentValues");
// ...
}
// 预加载资源
private static void preLoadResources() {
// 预加载常用资源
Resources resources = Resources.getSystem();
preloadColor(resources, 0);
preloadColor(resources, 1);
// ...
}4.4 Zygote 启动优化
Zygote64 与 Zygote32：
ini
# init.rc 中的 Zygote 服务定义
service zygote /system/bin/app_process \
-Xzygote \
--class-path=/system/framework.jar \
--base=/system/framework \
--zygote \
--start-system-server \
--socket-name=zygote
service zygote64 /system/bin/app_process64 \
-Xzygote \
--class-path=/system/framework.jar \
--zygote \
--socket-name=zygote645. SystemServer 启动
5.1 SystemServer 启动概述
SystemServer 是 Android 框架层的核心进程，负责启动所有系统服务。
SystemServer 启动流程：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ Zygote fork SystemServer │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ SystemServer.main() │ │
│ │ - 创建 VMRuntime │ │
│ │ - 加载 SystemServer 类 │ │
│ │ - 调用 run() 方法 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ SystemServer 初始化 │ │
│ │ - 创建 VMRuntime │ │
│ │ - 注册系统服务 │ │
│ │ - 启动核心服务 │ │
│ │ - 启动应用服务 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ SystemServer 服务启动顺序 │ │
│ │ 1. ActivityManagerService │ │
│ │ 2. SystemServer 进程初始化 │ │
│ │ 3. 其他核心服务 │ │
│ └─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘5.2 SystemServer 源码分析
SystemServer.java 主入口：
java
// frameworks/base/cmdline/SystemServer.java
public static void main(String[] args) {
new SystemServer().run();
}
public void run() {
// 1. 创建 VMRuntime
VMRuntime.getRuntime().setTargetSdkVersion(999);
// 2. 启动 SystemServer 进程
init2();
// 3. 注册系统服务
registerServices();
// 4. 启动核心服务
startCoreServices();
// 5. 启动应用服务
startAppServices();
}
private void init2() {
// 1. 设置系统属性
SystemProperties.set("sys.boot_completed", "1");
// 2. 初始化 Context
mSystemContext = ContextImpl.createAppContext(
VMRuntime.getRuntime(),
new PackageInfo(PackageInfo.PACKAGE_NAME)
);
// 3. 初始化 InputManager
InputManager.init(mSystemContext);
// 4. 初始化其他服务
// ...
}服务启动顺序：
java
// frameworks/base/services/java/com/android/server/SystemServer.java
public void run() {
// 第一阶段：核心服务
// 1. ActivityManager
mActivityManagerService = new ActivityManagerService();
// 2. WindowManager
mWindowManagerService = new WindowManagerService();
// 3. InputManager
mInputManagerService = new InputManager();
// 第二阶段：系统服务
// 4. PackageManager
mPackageManagerService = new PackageManagerService();
// 5. PowerManager
mPowerManagerService = new PowerManagerService();
// 6. AudioService
mAudioService = new AudioService();
// 第三阶段：应用服务
// 7. TelephonyService
// 8. LocationService
// 9. 其他服务
// ...
}5.3 ActivityManagerService 启动
java
// frameworks/base/services/java/com/android/server/am/ActivityManagerService.java
public ActivityManagerService() {
// 1. 初始化
mActivityController = new ActivityTaskManagerService(this);
// 2. 创建进程记录
mProcessRecords = new HashMap<String, ProcessRecord>();
// 3. 初始化应用列表
mAppRecords = new HashMap<ApplicationRecord, ApplicationRecord>();
// 4. 注册系统服务
mSystemServer.registerService(ActivityManagerService.class.getName(), this);
}
public void start() {
// 1. 启动 AMS 服务
mActivityController.start();
// 2. 加载系统应用
loadSystemApplications();
// 3. 启动系统进程
startSystemProcesses();
// 4. 启动 Launcher
startLauncher();
}5.4 PackageManagerService 启动
java
// frameworks/base/services/java/com/android/server/pm/PackageManagerService.java
public PackageManagerService(Context context, Installer installer,
boolean onlyCore) {
// 1. 初始化 PMS
mInstaller = installer;
mOnlyCore = onlyCore;
// 2. 加载包管理器
mPackageParser = new PackageParser();
// 3. 扫描已安装应用
scanPackage();
}
public void scanPackage() {
// 1. 扫描系统应用目录
scanPackageDir("/system/app");
// 2. 扫描用户应用目录
scanPackageDir("/data/app");
// 3. 解析 APK 文件
// 4. 验证签名
// 5. 安装应用
}5.5 服务启动时序图
SystemServer 服务启动时序：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 0ms ──→ SystemServer.main() │
│ ──→ 创建 VMRuntime │
│ ──→ SystemServer.run() │
│ │
│ 100ms ──→ ActivityManagerService 创建 │
│ ──→ AMS 初始化完成 │
│ ──→ AMS 注册到 ServiceManager │
│ │
│ 200ms ──→ WindowManagerService 创建 │
│ ──→ WMS 初始化完成 │
│ ──→ WMS 注册到 ServiceManager │
│ │
│ 300ms ──→ PackageManagerService 创建 │
│ ──→ PMS 扫描系统应用 │
│ ──→ PMS 注册到 ServiceManager │
│ │
│ 500ms ──→ 其他系统服务启动 │
│ ──→ 服务启动完成 │
│ │
└─────────────────────────────────────────────────────────────────┘6. Launcher 启动
6.1 Launcher 启动概述
Launcher 是用户看到的第一个应用，是 Android 系统的重要入口。
Launcher 启动流程：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ SystemServer 启动完成后 │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ AMS 启动 Launcher │ │
│ │ - 创建 Launcher 进程 │ │
│ │ - 启动 LauncherActivity │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ Launcher 进程初始化 │ │
│ │ - 加载 Launcher 应用 │ │
│ │ - 创建 LauncherActivity │ │
│ │ - 初始化布局 │ │
│ │ - 加载图标 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ LauncherActivity 生命周期 │ │
│ │ - onCreate() │ │
│ │ - onStart() │ │
│ │ - onResume() │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ Launcher 显示完成 │ │
│ └─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘6.2 Launcher 启动源码分析
Launcher 启动过程：
java
// frameworks/base/services/java/com/android/server/am/ActivityManagerService.java
public final void startLauncherActivity(IActivityStarter starter,
int userId) {
// 1. 获取 Launcher 组件名
ComponentName componentName = new ComponentName(
"com.android.launcher3",
"com.android.launcher3.Launcher"
);
// 2. 创建 Intent
Intent intent = new Intent();
intent.setComponent(componentName);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 3. 启动 Launcher Activity
ActivityStack stack = mRootTaskStack;
stack.resumeTopActivityUncheckedOrder(false);
// 4. 创建 Launcher 进程
mProcessRecords.put(LAUNCHER_PROCESS_NAME, launcherProcess);
// 5. 启动进程
startProcessAsync(launcherProcess, true);
}Launcher.java onCreate：
java
// packages/apps/Launcher3/src/com/android/launcher3/Launcher.java
public class Launcher extends Activity implements ... {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 1. 设置主题
setTheme(R.style.Theme_Launcher);
// 2. 设置内容视图
setContentView(R.layout.launcher);
// 3. 初始化工作空间
mWorkspace = findViewById(R.id.workspace);
mWorkspace.onFinishLoading();
// 4. 加载图标
mModel = LauncherModel.getInstance(this);
mModel.loadIcons();
// 5. 初始化文件夹
mFolderController = new FolderController(this);
// 6. 初始化拖放功能
mDragLayer = findViewById(R.id.drag_layer);
mDragController = new DragController(this);
// 7. 显示工作空间
mWorkspace.show();
}
@Override
protected void onStart() {
super.onStart();
// 注册广播接收器
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_SCREEN_ON);
filter.addAction(Intent.ACTION_SCREEN_OFF);
filter.addAction(Intent.ACTION_USER_PRESENT);
registerReceiver(mBroadcastReceiver, filter);
}
@Override
protected void onResume() {
super.onResume();
// 更新视图
mWorkspace.onResume();
// 恢复焦点
mWorkspace.requestFocus();
}
}6.3 Launcher 初始化优化
异步加载优化：
java
// 异步加载图标
public void loadIconsAsync() {
new AsyncTask<Void, Void, List<Icon>>() {
@Override
protected List<Icon> doInBackground(Void... params) {
// 后台加载图标
return loadIcons();
}
@Override
protected void onPostExecute(List<Icon> icons) {
// 更新 UI
updateIcons(icons);
}
}.execute();
}7. App 冷启动/热启动流程
7.1 启动类型对比
冷启动 vs 热启动：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 冷启动 (Cold Start) │
│ ┌─────────────────────────────────────┐ │
│ │ 1. 进程不存在 │ │
│ │ 2. 需要创建新进程 │ │
│ │ 3. 加载 APK │ │
│ │ 4. 初始化 Application │ │
│ │ 5. 创建 Activity │ │
│ │ 6. 加载布局 │ │
│ │ 7. 执行 onCreate/onStart/onResume │ │
│ └─────────────────────────────────────┘ │
│ │
│ 热启动 (Hot Start) │
│ ┌─────────────────────────────────────┐ │
│ │ 1. 进程已存在 │ │
│ │ 2. 复用已启动的进程 │ │
│ │ 3. 直接从栈中恢复 Activity │ │
│ │ 4. 执行 onStart/onResume │ │
│ └─────────────────────────────────────┘ │
│ │
│ 温启动 (Warm Start) │
│ ┌─────────────────────────────────────┐ │
│ │ 1. 进程已存在 │ │
│ │ 2. 复用已启动的进程 │ │
│ │ 3. 重新创建 Activity │ │
│ │ 4. 执行 onCreate/onStart/onResume │ │
│ └─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘7.2 冷启动详细流程
冷启动流程详细图：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ User 点击 Icon │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 1. Launcher 发送启动请求 │ │
│ │ startActivity(intent) │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 2. AMS 接收启动请求 │ │
│ │ ActivityManagerService.startActivity() │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 3. AMS 检查进程状态 │ │
│ │ - 进程不存在 │ │
│ │ - 创建新进程 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 4. AMS 调用 Zygote fork 进程 │ │
│ │ startProcessLocked() │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 5. Zygote fork 创建新进程 │ │
│ │ forkAndSpecialize() │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 6. 新进程初始化 │ │
│ │ - 加载 Application ClassLoader │ │
│ │ - 创建 Application 对象 │ │
│ │ - 调用 Application.onCreate() │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 7. 创建 Activity │ │
│ │ - 调用 ActivityThread.main() │ │
│ │ - 创建 Activity 对象 │ │
│ │ - 调用 Activity.onCreate() │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 8. 布局渲染 │ │
│ │ - 解析布局文件 │ │
│ │ - 创建视图树 │ │
│ │ - 测量和布局 │ │
│ │ - 绘制显示 │ │
│ └─────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────┐ │
│ │ 9. 启动完成 │ │
│ │ - Activity 显示 │ │
│ └─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘7.3 冷启动源码分析
ActivityManagerService.startActivity：
java
// frameworks/base/services/java/com/android/server/am/ActivityManagerService.java
public final int startActivity(IActivityStarter caller,
Intent intent,
String resolvedType,
ActivityRecord resultTo,
int userId) {
// 1. 获取调用者信息
ProcessRecord callerApp = getAppRecordForIntent(intent, userId);
// 2. 解析 Intent
ActivityRecord activityRecord = new ActivityRecord(
intent, resolvedType, callerApp, userId);
// 3. 检查进程是否存在
ProcessRecord processRecord = getProcessRecord(activityRecord.info.packageName);
if (processRecord == null) {
// 4. 进程不存在，创建新进程
processRecord = startProcessLocked(
activityRecord.info.packageName,
activityRecord.info.processName,
true,
0,
null,
null,
true,
false
);
}
// 5. 将 Activity 加入任务栈
mStackSupervisor.startActivity(activityRecord);
// 6. 启动 Activity
processRecord.startActivity(activityRecord);
return 0;
}ActivityThread.main：
java
// frameworks/base/core/java/android/app/ActivityThread.java
public static void main(String[] args) {
// 1. 创建 ActivityThread 实例
ActivityThread thread = new ActivityThread();
// 2. 附着到系统服务
thread.attach(false);
// 3. 进入消息循环
Looper.loop();
}
private void attach(boolean system) {
// 1. 获取 Application
mApplication = createApplication();
// 2. 创建 Activity
Activity activity = createActivity(
intent,
mApplication,
activityInfo
);
// 3. 调用 Activity 生命周期
activity.performCreate();
activity.performStart();
activity.performResume();
}7.4 热启动优化
Activity 复用策略：
java
// ActivityStack.java
private ActivityRecord topActivity() {
// 1. 获取任务栈顶的 Activity
TaskRecord task = mTopTask;
if (task != null) {
return task.topActivity();
}
// 2. 如果没有任务栈，创建新任务
// ...
}
private void resumeTopActivityLocked() {
// 1. 获取栈顶 Activity
ActivityRecord top = topActivity();
if (top != null) {
// 2. 如果进程存在，直接恢复
if (top.getProcess() != null && top.getProcess().isAlive()) {
// 热启动
resumeActivityLocked(top);
} else {
// 3. 如果进程不存在，冷启动
startProcessLocked(top.getProcessName());
}
}
}7.5 启动时间统计
启动时间分布：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 进程创建时间：~50-100ms │
│ └─ Zygote fork + 进程初始化 │
│ │
│ Application 初始化：~50-200ms │
│ └─ Application.onCreate() │
│ │
│ Activity 创建时间：~100-300ms │
│ └─ Activity.onCreate() + onRestoreInstanceState() │
│ │
│ 布局加载时间：~50-200ms │
│ └─ XML 解析 + View 创建 + 测量 + 布局 │
│ │
│ 总冷启动时间：~300-800ms │
│ │
│ 热启动时间：~50-150ms │
│ └─ 直接从栈中恢复 Activity │
│ │
└─────────────────────────────────────────────────────────────────┘8. Activity 启动流程源码分析
8.1 Activity 启动完整流程
Activity 启动完整源码流程：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 调用方 │
│ ├─ startActivity(intent) │
│ └─ PackageManagerService 解析 Intent │
│ │
│ ├─ ActivityManagerService │
│ │ ├─ startActivity() │
│ │ ├─ startActivityAsUser() │
│ │ ├─ startActivityMayWait() │
│ │ └─ startActivityLocked() │
│ │ │
│ ├─ TaskStackManager │
│ │ ├─ startActivity() │
│ │ ├─ checkStartActivityConstraints() │
│ │ └─ startActivity() │
│ │ │
│ ├─ ActivityStack │
│ │ ├─ startActivity() │
│ │ ├─ startActivityUnchecked() │
│ │ └─ startActivity() │
│ │ │
│ ├─ ProcessRecord │
│ │ ├─ startProcessLocked() │
│ │ └─ 创建进程 │
│ │ │
│ ├─ ActivityThread │
│ │ ├─ main() │
│ │ ├─ attach() │
│ │ └─ handleMessage() │
│ │ │
│ ├─ Activity │
│ │ ├─ onCreate() │
│ │ ├─ onStart() │
│ │ └─ onResume() │
│ │ │
│ └─ WindowManager │
│ ├─ addView() │
│ └─ 显示窗口 │
│ │
└─────────────────────────────────────────────────────────────────┘8.2 源码详细解析
1. Application.startActivity：
java
// frameworks/base/core/java/android/app/ContextImpl.java
public void startActivity(Intent intent) {
// 1. 获取 ActivityManager
IActivityManager service = ActivityManager.getService();
// 2. 调用 startActivity
service.startActivity(
null,
intent,
null,
null,
ActivityOptions.makeReadOnly()
);
}2. ActivityManagerService.startActivity：
java
// frameworks/base/services/java/com/android/server/am/ActivityManagerService.java
@Override
public final int startActivity(
IApplication caller,
String callingPackage,
Intent intent,
String resolvedType,
IVoiceInteraction voiceInteraction,
ActivityOptions options,
String resultWho,
int requestCode,
int startFlags,
ProfilingInfo profilingInfo,
boolean ignoreTargetSecurity,
boolean fromSourceStack,
int userId,
IActivityResultReceiver resultReceiver) {
// 1. 获取调用者信息
ActivityRecord callerActivity = null;
if (caller != null) {
callerActivity = caller.getActivityRecord();
}
// 2. 解析 Intent
ActivityRecord targetActivity = new ActivityRecord(
intent, resolvedType, callerActivity, userId);
// 3. 获取应用信息
ApplicationInfo appInfo = mPM.getActivityInfo(
targetActivity.info.packageName, userId);
// 4. 创建启动参数
ActivityStartRecord startRecord = new ActivityStartRecord(
targetActivity, callerActivity, appInfo);
// 5. 调用 TaskStackManager
mStackSupervisor.startActivity(startRecord);
return 0;
}3. TaskStackManager.startActivity：
java
// frameworks/base/services/java/com/android/server/am/TaskStackManager.java
boolean startActivity(ActivityStartRecord startRecord) {
// 1. 检查启动约束
if (!checkStartActivityConstraints(startRecord)) {
return false;
}
// 2. 获取任务栈
TaskRecord task = getFocusedStack();
// 3. 启动 Activity
return task.startActivity(startRecord);
}
private boolean checkStartActivityConstraints(ActivityStartRecord startRecord) {
// 1. 检查 Launcher 是否启动完成
if (!mLauncherReady && startRecord.launcherActivity) {
return false;
}
// 2. 检查系统是否就绪
if (!mSystemReady) {
return false;
}
return true;
}4. ActivityStack.startActivity：
java
// frameworks/base/services/java/com/android/server/am/ActivityStack.java
boolean startActivity(ActivityStartRecord startRecord) {
// 1. 获取 Activity 信息
ActivityRecord r = startRecord.activity;
// 2. 检查进程状态
ProcessRecord process = r.getProcess();
if (process == null) {
// 3. 进程不存在，启动进程
mService.startProcessLocked(
r.info.packageName,
r.info.processName,
r.info.applicationInfo.flags & ActivityInfo.FLAG_DEBUGGABLE,
0,
null,
null,
true,
false);
}
// 4. 将 Activity 加入任务栈
r.addToTask();
// 5. 启动 Activity
return startActivityUnchecked(startRecord);
}5. 进程启动：
java
// frameworks/base/services/java/com/android/server/am/ActivityManagerService.java
final ProcessRecord startProcessLocked(
String processName,
ApplicationInfo info,
boolean knownToBeDead,
int intentFlags,
String hostingType,
String hostingPid,
boolean keepIfLarge,
boolean hideIfNotGid) {
// 1. 获取进程记录
ProcessRecord proc = getProcessRecordLocked(processName);
// 2. 如果进程不存在，创建进程
if (proc == null) {
proc = new ProcessRecord(processName, info);
}
// 3. 创建启动参数
List<String> args = new ArrayList<>();
args.add("--process=" + processName);
args.add("--nice=" + info.lru);
args.add("--uid=" + info.uid);
args.add("--runtime=" + info.name);
// 4. 调用 Zygote fork 进程
final long startTime = SystemClock.elapsedRealtime();
final int result = Process.start(args.toArray(new String[0]));
// 5. 更新进程状态
proc.startForkTime = SystemClock.elapsedRealtime();
return proc;
}6. ActivityThread 处理：
java
// frameworks/base/core/java/android/app/ActivityThread.java
public static void main(String[] args) {
// 1. 创建 ActivityThread
ActivityThread thread = new ActivityThread();
// 2. 附着到系统服务
thread.attach(false);
// 3. 进入消息循环
Looper.loop();
}
private void attach(boolean system) {
// 1. 设置当前 ActivityThread
sCurrentActivityThread = this;
// 2. 获取 Application
mApplication = createApplication();
// 3. 注册到 ActivityManager
IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mApplication);
} catch (RemoteException e) {
throw e;
}
}7. Activity 创建：
java
// frameworks/base/core/java/android/app/ActivityThread.java
private Activity performCreateActivity(
IBinder app,
String className,
Intent intent,
ActivityInfo info,
Configuration config) {
// 1. 创建类加载器
ClassLoader cl = getPackageClassLoader(info.applicationInfo);
// 2. 创建 Activity 类
Activity activity = null;
try {
activity = (Activity) cl.loadClass(className).newInstance();
} catch (Exception e) {
throw e;
}
// 3. 设置 Activity 属性
activity.setIntent(intent);
activity.setInfo(info);
// 4. 创建 Context
Context context = createContextForActivity(
activity,
app,
config
);
// 5. 调用 attach
activity.attach(context, this, getInstrumentation(),
app, info);
return activity;
}
private void callActivityOnCreate(Activity activity) {
// 1. 调用 onCreate
activity.performCreate(null);
// 2. 调用 onStart
activity.performStart();
// 3. 调用 onResume
activity.performResume();
}8.3 Activity 启动模式
Activity 启动模式：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ standard (标准模式) │
│ ├─ 每次启动创建新的 Activity 实例 │
│ ├─ 可以存在于多个任务栈中 │
│ └─ 默认启动模式 │
│ │
│ singleTop (栈顶模式) │
│ ├─ 如果栈顶是同类型 Activity，复用 │
│ ├─ 否则创建新的实例 │
│ └─ 适用于首页 │
│ │
│ singleTask (单任务模式) │
│ ├─ 在同一任务栈中只有一个实例 │
│ ├─ 复用时清除栈顶的 Activity │
│ └─ 适用于浏览器 │
│ │
│ singleInstance (单实例模式) │
│ ├─ 独占一个任务栈 │
│ ├─ 始终复用同一个实例 │
│ └─ 适用于电话、短信等系统应用 │
│ │
└─────────────────────────────────────────────────────────────────┘8.4 源码引用
关键源码文件：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ frameworks/base/core/java/android/app/ │
│ ├─ ContextImpl.java │
│ ├─ Activity.java │
│ ├─ ActivityThread.java │
│ ├─ Application.java │
│ └─ Context.java │
│ │
│ frameworks/base/services/java/com/android/server/am/ │
│ ├─ ActivityManagerService.java │
│ ├─ ActivityRecord.java │
│ ├─ ActivityStack.java │
│ ├─ ActivityStackSupervisor.java │
│ ├─ ProcessRecord.java │
│ ├─ TaskStackManager.java │
│ └─ AppProcess.java │
│ │
│ frameworks/base/core/java/android/app/invoke/ │
│ ├─ AppInvoke.java │
│ └─ IAppInvoke.java │
│ │
│ frameworks/base/core/java/com/android/internal/os/ │
│ ├─ ZygoteInit.java │
│ └─ Process.java │
│ │
└─────────────────────────────────────────────────────────────────┘9. 性能优化点
9.1 启动性能优化
启动性能优化策略：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 启动前优化 │
│ ├─ 预加载 │
│ │ ├─ Zygote 预加载常用类 │
│ │ ├─ SystemServer 预启动 │
│ │ └─ 预加载资源 │
│ │ │
│ ├─ 代码优化 │
│ │ ├─ 减少 APK 大小 │
│ │ ├─ 减少类数量 │
│ │ └─ 优化DEX 结构 │
│ │ │
│ └─ 资源优化 │
│ ├─ 压缩图片 │
│ ├─ 使用矢量图 │
│ └─ 减少资源数量 │
│ │
│ 启动中优化 │
│ ├─ 异步初始化 │
│ │ ├─ Application 异步初始化 │
│ │ ├─ Activity 异步加载布局 │
│ │ └─ 异步加载数据 │
│ │ │
│ ├─ 懒加载 │
│ │ ├─ 延迟加载非关键组件 │
│ │ ├─ 按需加载图片 │
│ │ └─ 按需初始化服务 │
│ │ │
│ └─ 布局优化 │
│ ├─ 简化布局层级 │
│ ├─ 使用 ConstraintLayout │
│ └─ 避免复杂动画 │
│ │
│ 启动后优化 │
│ ├─ 预加载 │
│ │ ├─ 预加载下一页数据 │
│ │ ├─ 预加载常用图片 │
│ │ └─ 预初始化服务 │
│ │ │
│ ├─ 缓存优化 │
│ │ ├─ 内存缓存 │
│ │ ├─ 磁盘缓存 │
│ │ └─ 网络缓存 │
│ │ │
│ └─ 进程保活 │
│ ├─ 前台服务 │
│ ├─ 进程间通信 │
│ └─ 广播接收 │
│ │
└─────────────────────────────────────────────────────────────────┘9.2 启动时间优化方案
1. Application 异步初始化：
java
// Application.java
public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
// 1. 初始化基础服务
initBaseServices();
// 2. 异步初始化其他服务
new Handler(Looper.getMainLooper()).post(() -> {
initAsyncServices();
});
// 3. 延迟初始化
ApplicationInitializer.initAsync(() -> {
initDeferredServices();
});
}
private void initAsyncServices() {
// 异步初始化分析 SDK
Analytics.init(this);
// 异步初始化网络库
Network.init();
// 异步初始化图片库
ImageLoader.init();
}
}2. Activity 异步加载：
java
// Activity.java
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 1. 立即显示启动页
setContentView(R.layout.activity_launch);
// 2. 异步加载主页面
new AsyncTask<Void, Void, Boolean>() {
@Override
protected Boolean doInBackground(Void... params) {
// 后台加载数据
loadData();
return true;
}
@Override
protected void onPostExecute(Boolean result) {
// 显示主页面
setContentView(R.layout.activity_main);
}
}.execute();
}
}3. 布局优化：
xml
<!-- 使用 ConstraintLayout 减少层级 -->
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ImageView
android:id="@+id/iv_icon"
android:layout_width="48dp"
android:layout_height="48dp"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintBottom_toTopOf="@+id/tv_title"/>
<TextView
android:id="@+id/tv_title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:layout_constraintTop_toBottomOf="@+id/iv_icon"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"/>
</androidx.constraintlayout.widget.ConstraintLayout>9.3 启动时间监控
使用 Trace 工具：
java
// 启动时间追踪
public class StartupTracer {
private static final String TAG = "StartupTracer";
public static void trace(String tag, String message) {
android.util.Log.d(TAG, tag + ": " + message);
Trace.beginSection(tag);
}
public static void endTrace(String tag) {
Trace.endSection();
}
}
// 在关键位置插入追踪
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
StartupTracer.trace("onCreate", "开始");
super.onCreate(savedInstanceState);
StartupTracer.endTrace("onCreate");
// ...
}
}9.4 启动性能测试
启动性能测试方法：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 工具测试 │
│ ├─ Android Studio Profiler │
│ │ ├─ CPU Profiler │
│ │ ├─ Memory Profiler │
│ │ └─ Network Profiler │
│ │ │
│ ├─ Systrace │
│ │ ├─ 系统追踪 │
│ │ └─ 性能分析 │
│ │ │
│ └─ Perfetto │
│ ├─ 性能分析 │
│ └─ 可视化展示 │
│ │
│ 手动测试 │
│ ├─ 计时测试 │
│ │ ├─ 从点击到首帧显示 │
│ │ └─ 从点击到完全加载 │
│ │ │
│ ├─ 多次测试 │
│ │ ├─ 冷启动测试 │
│ │ ├─ 热启动测试 │
│ │ └─ 温启动测试 │
│ │ │
│ └─ 统计分析 │
│ ├─ 平均值 │
│ ├─ 最大值 │
│ └─ 最小值 │
│ │
└─────────────────────────────────────────────────────────────────┘9.5 启动性能优化清单
启动性能优化检查清单：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 代码层面 │
│ ├─ [ ] 减少 APK 大小 │
│ ├─ [ ] 优化类加载 │
│ ├─ [ ] 异步初始化 │
│ ├─ [ ] 懒加载 │
│ ├─ [ ] 减少反射 │
│ └─ [ ] 优化算法 │
│ │
│ 资源层面 │
│ ├─ [ ] 压缩图片 │
│ ├─ [ ] 使用矢量图 │
│ ├─ [ ] 减少资源数量 │
│ ├─ [ ] 优化布局 │
│ └─ [ ] 减少布局层级 │
│ │
│ 架构层面 │
│ ├─ [ ] 优化架构设计 │
│ ├─ [ ] 模块化 │
│ ├─ [ ] 组件化 │
│ ├─ [ ] 动态化 │
│ └─ [ ] 服务化 │
│ │
│ 网络层面 │
│ ├─ [ ] 优化网络请求 │
│ ├─ [ ] 使用缓存 │
│ ├─ [ ] 预加载 │
│ ├─ [ ] 优化协议 │
│ └─ [ ] 使用 CDN │
│ │
└─────────────────────────────────────────────────────────────────┘10. 面试考点
10.1 基础考点
1. Android 启动流程是什么？
答案要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. Bootloader 启动 │
│ ├─ 硬件初始化 │
│ ├─ 内存检测 │
│ ├─ 加载 Kernel + DTB │
│ └─ 跳转到 Kernel │
│ │
│ 2. Kernel 初始化 │
│ ├─ 解压 Kernel │
│ ├─ 初始化硬件驱动 │
│ ├─ 挂载根文件系统 │
│ └─ 执行 init 程序 │
│ │
│ 3. Init 进程启动 │
│ ├─ 解析 init 配置文件 │
│ ├─ 启动核心服务 │
│ ├─ 启动 Zygote │
│ └─ 进入主循环 │
│ │
│ 4. Zygote 进程启动 │
│ ├─ 创建 JVM │
│ ├─ 预加载类 │
│ ├─ 创建 socket 服务器 │
│ └─ 等待 fork 请求 │
│ │
│ 5. SystemServer 启动 │
│ ├─ Zygote fork 进程 │
│ ├─ 加载 SystemServer 类 │
│ ├─ 启动系统服务 │
│ └─ 启动 Launcher │
│ │
│ 6. Launcher 启动 │
│ ├─ 创建 Launcher 进程 │
│ ├─ 加载 LauncherActivity │
│ ├─ 初始化布局 │
│ └─ 显示 Launcher │
│ │
└─────────────────────────────────────────────────────────────────┘2. Zygote 的作用是什么？
答案要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 进程快速创建 │
│ ├─ 通过 fork 机制快速创建进程 │
│ ├─ 共享父进程内存 │
│ └─ 减少进程启动时间 │
│ │
│ 2. 内存优化 │
│ ├─ 预加载常用类 │
│ ├─ 预加载资源 │
│ └─ 减少内存占用 │
│ │
│ 3. 代码优化 │
│ ├─ 预编译 DEX │
│ ├─ 预优化代码 │
│ └─ 减少启动时间 │
│ │
│ 4. 安全隔离 │
│ ├─ 进程隔离 │
│ ├─ 权限控制 │
│ └─ 沙箱机制 │
│ │
└─────────────────────────────────────────────────────────────────┘3. SystemServer 中有哪些核心服务？
答案要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 系统服务 │
│ ├─ ActivityManagerService │
│ ├─ WindowManagerService │
│ ├─ PackageManagerService │
│ ├─ PowerManagerService │
│ └─ InputManagerService │
│ │
│ 2. 应用服务 │
│ ├─ AudioService │
│ ├─ TelephonyService │
│ ├─ LocationService │
│ └─ NotificationManagerService │
│ │
│ 3. 其他服务 │
│ ├─ SensorService │
│ ├─ VibratorService │
│ ├─ ConnectivityService │
│ └─ ClipboardService │
│ │
└─────────────────────────────────────────────────────────────────┘10.2 进阶考点
1. Activity 启动流程详解？
答案要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 应用层调用 │
│ ├─ Context.startActivity() │
│ ├─ 调用 ActivityManager.getService() │
│ └─ 调用 startActivity() │
│ │
│ 2. AMS 处理 │
│ ├─ 解析 Intent │
│ ├─ 获取 Activity 信息 │
│ ├─ 检查进程状态 │
│ ├─ 创建进程（如果需要） │
│ ├─ 将 Activity 加入任务栈 │
│ └─ 通知应用进程 │
│ │
│ 3. 进程创建 │
│ ├─ Zygote fork │
│ ├─ 创建新进程 │
│ ├─ 加载类 │
│ ├─ 创建 Application │
│ └─ 创建 Activity │
│ │
│ 4. Activity 生命周期 │
│ ├─ onCreate() │
│ ├─ onStart() │
│ ├─ onResume() │
│ └─ 显示界面 │
│ │
└─────────────────────────────────────────────────────────────────┘2. 冷启动和热启动的区别？
答案要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 冷启动 (Cold Start) │
│ ├─ 进程不存在 │
│ ├─ 需要创建新进程 │
│ ├─ 加载 APK │
│ ├─ 初始化 Application │
│ ├─ 创建 Activity │
│ ├─ 加载布局 │
│ └─ 时间：~300-800ms │
│ │
│ 热启动 (Hot Start) │
│ ├─ 进程已存在 │
│ ├─ 复用已启动进程 │
│ ├─ 直接从栈中恢复 Activity │
│ ├─ 调用 onStart/onResume │
│ └─ 时间：~50-150ms │
│ │
│ 温启动 (Warm Start) │
│ ├─ 进程已存在 │
│ ├─ 复用已启动进程 │
│ ├─ 重新创建 Activity │
│ ├─ 调用 onCreate/onStart/onResume │
│ └─ 时间：~150-300ms │
│ │
└─────────────────────────────────────────────────────────────────┘10.3 高级考点
1. Android 启动流程中的性能优化？
答案要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 系统层面优化 │
│ ├─ Zygote 预加载优化 │
│ ├─ SystemServer 启动优化 │
│ ├─ 减少系统服务启动时间 │
│ └─ 优化进程调度 │
│ │
│ 2. 应用层面优化 │
│ ├─ Application 异步初始化 │
│ ├─ Activity 异步加载布局 │
│ ├─ 减少初始化代码 │
│ ├─ 懒加载非关键组件 │
│ └─ 优化数据加载 │
│ │
│ 3. 资源层面优化 │
│ ├─ 压缩图片 │
│ ├─ 使用矢量图 │
│ ├─ 优化布局层级 │
│ ├─ 减少资源数量 │
│ └─ 使用预编译资源 │
│ │
│ 4. 架构层面优化 │
│ ├─ 模块化 │
│ ├─ 组件化 │
│ ├─ 动态化 │
│ └─ 服务化 │
│ │
└─────────────────────────────────────────────────────────────────┘2. 如何优化应用启动速度？
答案要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 代码优化 │
│ ├─ 异步初始化 │
│ ├─ 懒加载 │
│ ├─ 减少反射 │
│ ├─ 优化算法 │
│ └─ 减少类加载 │
│ │
│ 2. 布局优化 │
│ ├─ 简化布局层级 │
│ ├─ 使用 ConstraintLayout │
│ ├─ 使用 ViewStub │
│ ├─ 避免复杂动画 │
│ └─ 使用 RecyclerView │
│ │
│ 3. 资源优化 │
│ ├─ 压缩图片 │
│ ├─ 使用矢量图 │
│ ├─ 减少资源数量 │
│ ├─ 优化资源加载 │
│ └─ 使用资源预加载 │
│ │
│ 4. 网络优化 │
│ ├─ 异步加载数据 │
│ ├─ 使用缓存 │
│ ├─ 预加载 │
│ ├─ 优化网络请求 │
│ └─ 使用 CDN │
│ │
│ 5. 架构优化 │
│ ├─ 模块化 │
│ ├─ 组件化 │
│ ├─ 动态化 │
│ ├─ 服务化 │
│ └─ 微服务 │
│ │
└─────────────────────────────────────────────────────────────────┘10.4 面试问题集锦
问题 1：Zygote 为什么可以 fork 进程？
答案：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. Linux fork 机制 │
│ ├─ 拷贝父进程内存 │
│ ├─ 共享代码段 │
│ └─ 减少内存开销 │
│ │
│ 2. 预加载机制 │
│ ├─ Zygote 预加载常用类 │
│ ├─ 子进程共享父进程内存 │
│ └─ 减少类加载时间 │
│ │
│ 3. JVM 初始化 │
│ ├─ Zygote 中已初始化 JVM │
│ ├─ 子进程继承 JVM 状态 │
│ └─ 减少 JVM 初始化时间 │
│ │
│ 4. 性能优化 │
│ ├─ 减少进程创建时间 │
│ ├─ 优化内存使用 │
│ └─ 提高系统响应速度 │
│ │
└─────────────────────────────────────────────────────────────────┘问题 2：如何降低冷启动时间？
答案：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 减少初始化代码 │
│ ├─ 异步初始化 │
│ ├─ 延迟初始化 │
│ └─ 懒加载 │
│ │
│ 2. 优化布局 │
│ ├─ 简化布局层级 │
│ ├─ 使用 ConstraintLayout │
│ └─ 减少布局嵌套 │
│ │
│ 3. 优化资源 │
│ ├─ 压缩图片 │
│ ├─ 使用矢量图 │
│ └─ 减少资源数量 │
│ │
│ 4. 优化网络 │
│ ├─ 异步加载数据 │
│ ├─ 使用缓存 │
│ └─ 预加载 │
│ │
│ 5. 优化架构 │
│ ├─ 模块化 │
│ ├─ 组件化 │
│ └─ 服务化 │
│ │
└─────────────────────────────────────────────────────────────────┘总结
启动流程总结
Android 启动流程核心知识点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. Bootloader 启动 │
│ ├─ 硬件初始化 │
│ ├─ 加载 Kernel │
│ └─ 跳转到 Kernel │
│ │
│ 2. Kernel 初始化 │
│ ├─ 内存初始化 │
│ ├─ 设备驱动 │
│ ├─ 挂载根文件系统 │
│ └─ 执行 init 进程 │
│ │
│ 3. Init 进程启动 │
│ ├─ 解析配置文件 │
│ ├─ 启动核心服务 │
│ ├─ 启动 Zygote │
│ └─ 进入主循环 │
│ │
│ 4. Zygote 进程启动 │
│ ├─ 创建 JVM │
│ ├─ 预加载类 │
│ ├─ 创建 socket 服务器 │
│ └─ 等待 fork 请求 │
│ │
│ 5. SystemServer 启动 │
│ ├─ fork 进程 │
│ ├─ 启动系统服务 │
│ ├─ 启动 Launcher │
│ └─ 显示 Launcher │
│ │
│ 6. App 启动 │
│ ├─ 冷启动：创建进程 │
│ ├─ 热启动：复用进程 │
│ └─ 启动 Activity │
│ │
└─────────────────────────────────────────────────────────────────┘性能优化总结
启动性能优化核心要点：
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 代码优化 │
│ ├─ 异步初始化 │
│ ├─ 懒加载 │
│ ├─ 减少反射 │
│ └─ 优化算法 │
│ │
│ 2. 布局优化 │
│ ├─ 简化布局层级 │
│ ├─ 使用 ConstraintLayout │
│ └─ 减少布局嵌套 │
│ │
│ 3. 资源优化 │
│ ├─ 压缩图片 │
│ ├─ 使用矢量图 │
│ └─ 减少资源数量 │
│ │
│ 4. 网络优化 │
│ ├─ 异步加载数据 │
│ ├─ 使用缓存 │
│ └─ 预加载 │
│ │
│ 5. 架构优化 │
│ ├─ 模块化 │
│ ├─ 组件化 │
│ └─ 服务化 │
│ │
└─────────────────────────────────────────────────────────────────┘文档信息：
- 字数：约 18000 字
- 包含：Bootloader 启动、Kernel 初始化、Init 进程启动、Zygote 进程启动、SystemServer 启动、Launcher 启动、App 启动流程、Activity 启动流程源码分析、性能优化点、面试考点
- 源码引用：ZygoteInit.java、SystemServer.java、ActivityManagerService.java、ActivityThread.java、init.cpp 等
- ASCII 流程图：包含多个流程时序图和状态机图
- 最佳实践：启动性能优化策略、异步初始化方案、布局优化建议
建议：
- 学习源码时，结合 Android Studio 调试，跟踪关键方法调用
- 面试前，重点掌握启动流程的每个阶段和关键源码
- 性能优化方面，掌握实际优化案例和优化效果评估方法