在计算机启动过程和Linux内核Kernel启动过程介绍了计算机启动和内核加载，本篇文章主要介绍Android系统是如何启动的。

一、Android启动流程

Android系统的启动流程与Linux接近：

• 1.引导加载程序（Bootloader）启动： 当设备上电或者重启时，首先会由引导加载程序负责启动。引导加载程序通常存储在设备的固件中，它的主要任务是初始化硬件，并加载并启动操作系统内核。引导加载程序会首先运行自身的初始化代码，然后加载操作系统内核到内存中。
• 2.内核加载： 引导加载程序会根据预定义的配置从设备存储中加载操作系统内核。在Android设备中，通常使用的是Linux内核。引导加载程序将内核加载到内存中的指定位置。
• 3.内核初始化： 一旦内核加载到内存中，引导加载程序会将控制权转交给内核。内核开始执行初始化过程，包括对硬件进行初始化、建立虚拟文件系统、创建进程和线程等。
• 4.启动 init 进程： 内核初始化完成后，会启动名为init的用户空间进程。init进程是Android系统的第一个用户空间进程，它负责系统的进一步初始化和启动。init进程会读取系统配置文件（例如 init.rc），并根据其中的指令启动系统服务和应用程序。
• 5.启动 Zygote 进程： 在init进程启动后，会启动名为Zygote的进程。Zygote进程是Android应用程序的孵化器，它会预加载常用的Java类和资源，以加速应用程序的启动。
• 6.启动系统服务： 在Zygote进程启动后，还会启动一系列系统服务，例如SurfaceFlinger、ActivityManager、PackageManager等。这些系统服务负责管理系统的各个方面，包括显示、应用程序生命周期、包管理等。
• 7.启动桌面程序： 一旦系统服务启动完成，Android系统就处于可用状态。就会启动桌面程序，用户可以开始启动应用程序并使用设备进行各种操作了。

在计算机启动过程和Linux内核Kernel启动过程已经介绍了计算机启动和内核加载，所以本篇文章从Zygote进程开始介绍。

二、Zygote进程(孵化器进程)

1.Zygote简介

• Zygote进程是一个用户进程，由init进程(1号进程)fork而来。
• Zygote进程的主要任务是加载系统的核心类库（如Java核心库和Android核心库）和安卓系统服务(SystemService)，然后进入一个循环，等待请求来创建新的 Android 应用程序进程。
• Zygote进程通过fork的方式创建新的应用程序进程。

2.Zygote进程的创建

Zygote进程在系统启动时由init进程创建。init进程是Linux系统中的第一个用户空间进程，它通过解析init.rc文件来启动各种服务和进程，包括Zygote。具体流程如下：

2.1 启动init进程：

• 系统启动后，内核会加载并运行init进程。
• init进程读取并解析init.rc配置文件。

init进程的启动可参考Linux内核Kernel启动过程

2.2 init.rc脚本：

init.rc文件中包含启动Zygote的指令脚本的主要代码：

// 创建zygote服务
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
// 创建zygote socket，与系统和应用程序做通信
socket zygote stream 660 root system
// 定义了zygote服务重启时的一些操作
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server:

• service zygote: 定义一个名为zygote的服务
• /system/bin/app_process：这是启动Zygote进程的可执行文件，64位系统为app_process64。
• -Xzygote：标志表明这是一个Zygote进程启动的特殊模式。
• /system/bin：指定进程的工作目录。
• --zygote：告诉app_process以Zygote模式启动。
• --start-system-server：Zygote启动时还要启动System Server进程，这是Android系统中管理关键系统服务的核心进程。

class main:

• 将Zygote服务归类为main类别。
• Android系统在启动过程中会启动所有“main”类别的服务。

socket zygote stream 660 root system:
创建了一个名为zygote的UNIX域Socket套接字，用于其他进程与Zygote进程通信。

onrestart write /sys/android_power/request_state wake：
当zygote服务重启时，系统应该将“/sys/android_power/request_state”文件的内容设置为“wake”，以唤醒设备。

onrestart write /sys/power/state on：
当zygote服务重启时，系统应该将“/sys/power/state”文件的内容设置为 “on”，以打开电源。

onrestart restart media：
当zygote服务重启时，系统应该重启媒体服务（如音频、视频等），以恢复媒体功能。

onrestart restart netd：
当zygote服务重启时，系统应该重启网络守护进程（netd），以恢复网络功能。

2.3 app_process文件

/system/bin/app_process是Android中的一个关键可执行文件，负责启动Zygote进程和应用进程。

Android14的app_process源码地址

2.3.1 main方法

app_process主入口点是main方法，它是整个进程启动流程的起点。以下是其主要代码和解释：

以下是关键代码说明:

int main(int argc, char* const argv[])
{
    // 创建并初始化AppRuntime对象runtime
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    
    // 初始化参数zygote,startSystemServer,application,niceName,className
    // 代码见源码，此处略
    
    // 解析命令行参数
    // 代码见源码，此处略

    // 构建传递给 Java 初始化类的参数列表
    // 代码见源码，此处略
    
    if (zygote) {
        // 调用AppRuntime的start方法，开始加载ZygoteInit类
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (!className.isEmpty()) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
}

2.3.2 AppRuntime类(AndroidRuntime)

AppRuntime继承自AndroidRuntime(ART)，是Android中的一个关键类，负责管理和启动 Android 应用程序或系统服务的 Java 虚拟机 (JVM)。

Android14的AndroidRuntime源码地址

2.3.2.1 AndroidRuntime类的start方法

app_process的main方法调用了AppRuntime的start方法，也就是AppRuntime的父类AndroidRuntime的start方法

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    // 初始化Java Native Interface (JNI)。JNI是Java和C/C++之间的接口，它允许Java代码和C/C++代码相互调用
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    
    JNIEnv* env;  // JNIEnv环境指针
    // 初始化虚拟机
    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
        return;
    }

    // 注册JNI方法
    if (startReg(env) < 0) {
        return;
    }

    /*
     * 以下代码执行后，当前线程（即运行 AndroidRuntime::start 方法的线程）将成为Java虚拟机（JVM）的主线程，并且在调用env->CallStaticVoidMethod启动指定的Java类的 main 方法后，这个方法不会返回，直到 JVM 退出为止。(官方文档说明)
     */
    
    // 将"com.android.internal.os.ZygoteInit"转换为"com/android/internal/os/ZygoteInit"
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        // 没有找到ZygoteInit.main()方法
    } else {
        // 通过JNI调用ZygoteInit.main()方法
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
    }
}

• 创建虚拟机
• 注册JNI方法
• 通过JNI调用ZygoteInit.main()

3.Zygote进程

在AndroidRuntime的start方法，通过JNI调用ZygoteInit.main()，系统第一次进入Java层(ZygoteInit是系统运行的第一个Java类)，当前线程也正式成为Java虚拟机（JVM）的主线程。

Android14的ZygoteInit源码地址

3.1 ZygoteInit.main()

通过main方法完成资源预加载、启动系统服务等功能，为Launcher桌面程序做准备。

public static void main(String[] argv) {
    // 创建ZygoteServer
    ZygoteServer zygoteServer = null;
    ...
    // 预加载资源
    preload(bootTimingsTraceLog);
    ...
    // 初始化ZygoteServer
    zygoteServer = new ZygoteServer(isPrimaryZygote);
    ...
    // 通过fork的形式初始化SystemServer
    Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
    if (r != null) {
        r.run();
        return;
    }
    ...
    // 启动Loop，监听消息
    caller = zygoteServer.runSelectLoop(abiList);
    ...
}

3.2 ZygoteInit.preload()预加载

通过preload方法预加载系统常用的类、资源和库，能够显著减少应用启动时的延迟，并通过共享这些预加载的内容来降低内存使用，提高系统性能。

static void preload(TimingsTraceLog bootTimingsTraceLog) {
    preloadClasses(); //加载常用的Java类
    preloadResources(); //加载常用的资源（如布局、图片等）
    preloadOpenGL(); //加载OpenGL库
    preloadSharedLibraries(); //加载常用的本地共享库
    preloadTextResources(); //加载常用的文本资源
    ...
}

3.2.1 常用类

• Android框架中的基础类，如Activity、Service、BroadcastReceiver等。
• 常用的UI组件类，如TextView、Button、ImageView等。

3.2.2 常用资源

常用布局文件（layout）。
常用图片资源（drawable）。
常用字符串（strings.xml）。

3.2.3 常用库

标准C库（libc.so）。
图形处理库（libskia.so）。
OpenGL ES库（libGLESv2.so）。

3.3 启动System Server

System Server是Android系统中的关键进程，负责启动和管理核心系统服务。

启动过程的核心代码:

public static void main(String argv[]) {
    // 初始化ZygoteServer
    ZygoteServer zygoteServer = new ZygoteServer();
    // 启动System Server
    if (startSystemServer) {
        startSystemServer(abiList, socketName, zygoteServer);
    }
    // 进入Zygote的主循环，等待新进程的启动请求
    zygoteServer.runSelectLoop();
}

private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer) {
    /* 调用native方法fork系统服务器 */
    int pid = Zygote.forkSystemServer(...);
    if (pid == 0) {
        // 在子进程中执行System Server的main方法
        handleSystemServerProcess(parsedArgs);
    }
}

private static void handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
    // 通过反射调用SystemServer的main方法
    ClassLoader cl = ClassLoader.getSystemClassLoader();
    Class<?> clz = cl.loadClass("com.android.server.SystemServer");
    Method m = clz.getMethod("main", new Class[] { String[].class });
    m.invoke(null, new Object[] { parsedArgs.remainingArgs });
}

• ZygoteServer是一个Socket,Zygote进程通过这个Socket和SystemService及其他应用程序进程做通信
• 通过fork创建的SystemServer进程是一个独立运行的进程，避免SystemServer进程受到其他进程的影响。
• 关于SystemServer，后面还会更详细的介绍

三、系统服务 System Server

在Zygote中通过Zygote.forkSystemServer方法创建了System Server进程，然后通过Java的反射机制调用com.android.server.SystemServer的main方法来启动System Server。

Android14的System Server源码地址

3.1 SystemServer.java

在SystemServer.java的main方法调用了自身的run方法，在run方法中启动了具体的系统服务，代码如下：

public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
    // 初始化系统属性，时区、语言、环境等，代码略
    ...
    // 加载本地服务
    System.loadLibrary("android_servers");
    ...
    // 初始化系统上下文
    createSystemContext();
    // 初始化主线模块
    ActivityThread.initializeMainlineModules();
    ...
    // 创建系统服务管理器
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    ...

    /* 启动系统服务 */
    // 启动引导服务
    startBootstrapServices(t);
    // 启动核心服务
    startCoreServices(t);
    // 启动其他服务
    startOtherServices(t);
    // 启动 APEX 服务
    startApexServices(t);
    ...
}

3.2 System Server启动的主要服务

以下为System Server启动的主要服务列表，具体实现可在源码中查看。

在系统服务全部启动完成后，就开始启动系统桌面程序Launcher了。

四、桌面程序Launcher

• SystemServer 启动所有服务: SystemServer类在run方法中调用startOtherServices方法，启动其他系统服务，包括ActivityManagerService。
• ActivityManagerService准备系统: ActivityManagerService 在systemReady方法中调用mAtmInternal.startHomeOnAllDisplays方法，开始在所有显示器上启动桌面程序。
• ActivityTaskManagerService启动: Home Activity:ActivityTaskManagerService 调用RootWindowContainer的startHomeOnAllDisplays方法。
• RootWindowContainer循环所有显示器: RootWindowContainer 遍历每个显示器，并调用startHomeOnDisplay方法。
• 启动Home Activity: 在每个显示器上，通过TaskDisplayArea调用ActivityStartController的startHomeActivity方法，最终调用ActivityManagerService的startActivity方法启动Home Activity。
• Home应用启动: ActivityManagerService处理启动请求，启动Home应用的Activity展示桌面界面。

核心代码流转:

4.1 SystemServer.java

Android14的System Server源码地址

private void run() {
    ...
    // 启动其他服务
    startOtherServices(t);
    ...
}

private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
    ...
    // 启动ActivityManagerService
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    ...
    // 启动Launcher
    mActivityManagerService.systemReady(...)
    ...
}

4.2 桌面程序Launcher(Home)的启动流程

4.2.1 ActivityManagerService.java

Android14的ActivityManagerService源码地址

public void systemReady(final Runnable goingCallback, TimingsTraceAndSlog t) {
    ...
    // 在所有显示器上启动Launcher
    mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
    ...
}

• 此行代码最终会调用到ActivityTaskManagerService.java的startHomeOnAllDisplays方法

4.2.2 ActivityTaskManagerService.java

Android14的ActivityTaskManagerService源码地址

void startHomeOnAllDisplays(int userId, String reason) {
    synchronized (mGlobalLock) {
        // 在所有显示器上启动Launcher
        return mRootWindowContainer.startHomeOnAllDisplays(userId, reason);
    }
}

• 此行代码最终会调用到RootWindowContainer.java的startHomeOnAllDisplays方法

4.2.3 RootWindowContainer.java

Android14的RootWindowContainer源码地址

boolean startHomeOnAllDisplays(int userId, String reason) {
    boolean homeStarted = false;
    for (int i = getChildCount() - 1; i >= 0; i--) {
        final int displayId = getChildAt(i).mDisplayId;
        // 在每一个显示器上启动桌面程序
        homeStarted |= startHomeOnDisplay(userId, reason, displayId);
    }
    return homeStarted;
}

boolean startHomeOnDisplay(int userId, String reason, int displayId) {
    return startHomeOnDisplay(userId, reason, displayId, false, false);
}

boolean startHomeOnDisplay(int userId, String reason, int displayId, boolean allowInstrumenting, boolean fromHomeKey) {
    ...
    // 调用startHomeOnTaskDisplayArea
    return display.reduceOnAllTaskDisplayAreas((taskDisplayArea, result) ->
                    result | startHomeOnTaskDisplayArea(userId, reason, taskDisplayArea,
                            allowInstrumenting, fromHomeKey),false);
}

boolean startHomeOnTaskDisplayArea(int userId, String reason, TaskDisplayArea taskDisplayArea,
        boolean allowInstrumenting, boolean fromHomeKey) {
    ...
    Intent homeIntent = mService.getHomeIntent();
    mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
            taskDisplayArea);
    ...
    return true;
}

• 最终通过Intent和startHomeActivity方法启动了桌面程序

五、总结

通过上述介绍，从用户按下电源键开始，经过Bootloader启动、内核启动、init进程启动、Zygote进程启动、SystemServer进程启动，以及系统应用的启动，最终进入桌面环境。

每个阶段都的核心工作：

1. Bootloader启动：初始化硬件并加载内核。

2. 内核启动：内核是操作系统的核心，负责管理系统资源和硬件设备。

3. init进程启动：init进程通过解析init.rc文件来启动和配置系统服务。

4. Zygote进程启动：Zygote是Android系统的独有设计，负责创建应用进程。通过预加载资源和共享内存，Zygote大大提高了应用启动的速度和系统资源的利用率。

5. SystemServer进程启动：SystemServer进程启动了大量系统服务，如Activity Manager和Package Manager等，这些服务构成了Android系统的骨干，管理和协调应用的运行。

6. 启动系统应用：Launcher应用的启动标志着系统启动的完成。用户进入桌面，可以开始正常使用设备。

通过深入理解Android的启动流程，可以更有效地进行系统开发和维护，从而提供更高性能和更稳定的用户体验。

如有任何疑问或建议，欢迎留言讨论。

热门相关：间谍的战争   富二代修仙日常   从港综签到成为传说   爆萌宠妃：邪帝，要抱抱   极品明君