一、前置思考

1.1 从按下电源键到桌面出现：发生了什么

用户按下电源键，到看到桌面，中间经历：

电源键 → BootROM → BootLoader → 内核 → init → 系统服务 → 桌面应用
  30ms     100ms      300ms      500ms    200ms     800ms      500ms
                              ── 总共约 2.4 秒 ──

每个阶段都有优化空间：厂商宣传"1 秒开机"就是逐阶段压榨出来的。

1.2 启动慢的代价

❌ 冷启动 3s vs 1s: 用户感知天差地别
   → 调研显示: 启动 > 2s 用户会认为"坏了"

❌ 系统服务启动乱序: 应用启动时依赖的服务还没起来 → 崩溃

❌ 启动阶段卡死: 无法定位是哪一步 → 排查地狱

1.3 本文价值

剖析 BootLoader → 内核初始化 → init 进程 → 系统服务（ServiceManager）→ 应用孵化 完整启动链路，以及每一阶段的耗时分析和优化点。

二、核心原理

2.1 启动全链路时序

┌─────────────────────────────────────────────┐
│ ① BootROM (固化 ROM)                        │
│    上电 → 加载 BootLoader → 跳转             │
│    耗时: 30~100ms                            │
├─────────────────────────────────────────────┤
│ ② BootLoader (uboot/ABL)                    │
│    初始化硬件 → 校验镜像 → 加载内核          │
│    耗时: 200~500ms                           │
├─────────────────────────────────────────────┤
│ ③ 内核启动 (Kernel)                         │
│    解压 → 初始化核心子系统 → 挂载根文件系统  │
│    耗时: 400~800ms                           │
├─────────────────────────────────────────────┤
│ ④ init 进程 (PID 1)                         │
│    解析启动脚本 → 创建关键服务               │
│    耗时: 100~300ms                           │
├─────────────────────────────────────────────┤
│ ⑤ 系统服务启动                              │
│    ServiceManager → 核心服务 → 桌面          │
│    耗时: 500~1000ms                          │
└─────────────────────────────────────────────┘

2.2 内核初始化核心流程

内核启动流程 (start_kernel):
① 架构初始化: setup_arch (MMU/内存)
② 中断初始化: init_IRQ
③ 定时器初始化: time_init
④ 进程管理初始化: fork_init (PID 1 的雏形)
⑤ 内存管理初始化: mm_init
⑥ 块设备/文件系统: vfs_caches_init
⑦ 启动 init 进程: kernel_init → execve("/init")

2.3 init 进程与系统服务

init (PID 1) 职责:
  ① 挂载文件系统
  ② 解析启动脚本 (init.rc / cfg)
  ③ 启动 ServiceManager
  ④ 按依赖顺序启动系统服务
  ⑤ 启动桌面应用 (Launcher)

系统服务启动顺序（依赖关系）:
  ServiceManager (基础) → 包管理 → 窗口管理
  → 媒体服务 → 电源 → 定位 → 桌面

三、源码/API 深度解析

3.1 内核启动核心（start_kernel）

// Linux 内核启动入口
asmlinkage __visible void __init start_kernel(void)
{
    // 1. 架构初始化（MMU/内存布局）
    setup_arch(&command_line);
    // 2. 内存管理初始化
    mm_init();
    // 3. 调度器初始化
    sched_init();
    // 4. 中断初始化
    init_IRQ();
    // 5. 定时器初始化
    time_init();
    // 6. 进程管理（创建 PID 0/1 的基础）
    fork_init();
    // 7. 文件系统初始化
    vfs_caches_init();
    // 8. 启动第一个用户进程 init
    rest_init();
    // rest_init 内: kernel_thread(kernel_init) → PID 1
}

// 内核线程 kernel_init → exec init 进程
static int __ref kernel_init(void *unused)
{
    // 挂载根文件系统
    prepare_namespace();
    // 执行用户态 init
    if (ramdisk_execute_command) {
        // execve 替换为用户态 init 程序
    }
    return 0;
}

3.2 init 进程（用户态 PID 1）

// init 进程主逻辑
int main(int argc, char **argv)
{
    // 1. 挂载基础文件系统
    mount("proc", "/proc", "proc", 0, NULL);
    mount("sysfs", "/sys", "sysfs", 0, NULL);
    mount("devtmpfs", "/dev", "devtmpfs", 0, NULL);

    // 2. 解析启动脚本 (init.rc)
    parse_config_file("/etc/init.rc");

    // 3. 按服务依赖启动
    //    service_manager → hdf → media → ...
    for (service in action.schedule) {
        if (service.dependencies_met()) {
            fork_and_exec(service);  // 启动系统服务
        }
    }

    // 4. 启动桌面
    exec_launcher();

    // 5. 进入事件循环（监听子进程退出/重启）
    while (1) {
        waitpid(-1, &status, 0);   // 服务崩溃自动重启
    }
}

3.3 服务启动与依赖（ServiceManager 注册）

// 系统服务注册流程
// 服务启动时向 ServiceManager 注册

int main_service_main(void)
{
    // 1. 连接 ServiceManager (句柄 0)
    sp<IServiceManager> sm = defaultServiceManager();

    // 2. 注册服务（服务名 → Binder 节点）
    sm->addService(String16("sensor_service"),
                   new SensorService());

    // 3. 进入服务循环（等待客户端 Binder 调用）
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

// 客户端获取服务
sp<IBinder> binder = sm->getService(String16("sensor_service"));
// 之后通过 binder 直接调用（不再经过 SM）

3.4 应用孵化（App 启动）

// 应用启动（ArkTS 视角）
// 系统收到启动请求 → 应用孵化器创建进程
// → 加载 Ability → 执行 EntryAbility

@Entry
@Component
struct EntryAbility {
  onCreate(want: Want, launchParam: LaunchParam): void {
    // 应用进程创建完成，初始化环境
    LoggerUtil.info(TAG, '应用进程创建，PID=' + process.getPid());
  }

  onWindowStageCreate(windowStage: window.WindowStage): void {
    // 窗口创建 → 加载首页
    windowStage.loadContent('pages/Index');
  }
}

// 启动耗时分解:
// 进程创建 ~50ms → 环境初始化 ~80ms
// → Ability 加载 ~100ms → 首页渲染 ~300ms

四、企业级实战落地

4.1 启动优化清单

阶段	优化手段	收益
BootLoader	并行初始化硬件	-200ms
内核	裁剪非必要模块	-300ms
init	服务并行启动	-400ms
系统服务	延迟启动非关键服务	-300ms
应用	冷启动优化（懒加载）	-500ms

4.2 完整示例：启动链路演示

@Entry
@ComponentV2
struct BootFlowDemo {
  @Local stage: number = 0;
  @Local logs: string[] = [];
  @Local totalMs: number = 0;

  private stages: BootStage[] = [
    { name: 'BootROM', time: 80, desc: '固化 ROM 加载 BootLoader', color: '#4FC3F7' },
    { name: 'BootLoader', time: 320, desc: '初始化硬件 + 校验镜像 + 加载内核', color: '#69F0AE' },
    { name: '内核启动', time: 550, desc: 'MMU/中断/内存/调度 初始化', color: '#FFD54F' },
    { name: 'init进程', time: 250, desc: 'PID 1 挂载文件系统 + 启动脚本', color: '#CE93D8' },
    { name: '系统服务', time: 780, desc: 'ServiceManager → 核心服务 → 桌面', color: '#FF8A65' },
    { name: '桌面显示', time: 420, desc: 'Launcher 首帧渲染完成', color: '#81C784' }
  ];

  private runBoot(): void {
    this.logs = [];
    this.stage = 0;
    this.runNextStage(0, 0);
  }

  private runNextStage(idx: number, acc: number): void {
    if (idx >= this.stages.length) {
      this.totalMs = acc;
      this.logs.push('🏁 开机完成: 总耗时 ' + acc + 'ms（含硬件 120ms）');
      this.logs.push('⚡ 优化后: 并行启动可压缩至 1.6s');
      return;
    }
    const s = this.stages[idx];
    setTimeout(() => {
      this.logs.push('[' + s.name + '] +' + s.time + 'ms → ' + s.desc);
      this.stage = idx + 1;
      this.runNextStage(idx + 1, acc + s.time);
    }, 300);
  }

  build() {
    Column({ space: 12 }) {
      Text('🚀 系统启动全流程').fontSize(20).fontWeight(FontWeight.Bold)

      // 启动阶段条
      Row({ space: 6 }) {
        ForEach(this.stages, (s: BootStage, i: number) => {
          Column({ space: 3 }) {
            Text(s.name).fontSize(9)
            Text(s.time + 'ms').fontSize(9).fontWeight(FontWeight.Bold)
          }
          .layoutWeight(1).padding(6)
          .backgroundColor(i < this.stage ? s.color : 'rgba(255,255,255,0.05)')
          .borderRadius(6)
        }, (s: BootStage) => s.name)
      }
      .width('100%')

      Button('▶ 模拟开机流程').width('100%').height(46)
        .onClick(() => this.runBoot())

      if (this.totalMs > 0) {
        Text('总耗时: ' + this.totalMs + 'ms').fontSize(14).fontWeight(FontWeight.Bold)
          .fontColor('#69F0AE').width('100%')
      }

      Scroll() {
        Column() {
          ForEach(this.logs, (l: string) => {
            Text(l).fontSize(11).lineHeight(18).fontColor('rgba(255,255,255,0.8)').width('100%')
          }, (l: string, i: number) => l + i)
        }.width('100%')
      }
      .layoutWeight(1).width('100%').scrollBar(BarState.Off)
    }
    .width('100%').height('100%').padding(16)
    .backgroundColor('#0D1B2A')
  }
}

4.3 启动耗时分布与优化

阶段	默认耗时	优化后	手段
BootROM	80ms	60ms	硬件优化
BootLoader	320ms	150ms	并行硬件初始化
内核	550ms	250ms	裁剪 + 延迟初始化
init	250ms	120ms	脚本精简
系统服务	780ms	450ms	按需并行启动
桌面	420ms	280ms	首帧优先渲染
合计	2.4s	1.3s	接近 2 倍提升

五、问题排查与性能优化

问题	原因	解决
开机卡在 Logo	BootLoader 加载失败	查看串口日志定位阶段
服务启动崩溃	依赖服务未就绪	依赖关系声明
桌面启动慢	服务串行启动	并行 + 按需
应用启动闪退	依赖服务未起	应用侧重试等待
开机循环重启	init 服务崩溃	看 init 日志 + 单用户模式
首帧白屏	首页渲染慢	首帧只渲染骨架

5.1 启动优化要点

1. 阶段耗时量化: 每阶段打点，找出大头
2. 并行化: 无依赖的服务并行启动（收益最大）
3. 懒加载: 非关键服务延迟到使用时再启动
4. 内核裁剪: 用不到的驱动/子系统不编译
5. 首帧优先: 桌面先渲染骨架，数据后填充

六、高阶总结与最佳实践

1. 链路思维：启动是流水线，优化要找瓶颈阶段，不是平均用力。
2. 并行优先：服务间无依赖就并行，串行是启动慢的最大元凶。
3. 懒加载兜底：非关键服务延迟启动，用户感知不到的都可以后置。
4. 打点量化：每个阶段打点，启动优化要有数据支撑。
5. 首帧体验：用户看到桌面才算"启动完成"，首帧优先渲染。

一句话记住：启动全链路 = BootLoader（硬件就绪）→ 内核（系统就绪）→ init（服务编排）→ 系统服务（能力就绪）→ 桌面（体验就绪）——每一段都可优化，并行化和懒加载是两大杀器。