HarmonyOS开发：热启动优化与后台恢复加速

📌 核心要点：热启动是用户最频繁的启动场景，优化onForeground恢复速度、合理保存与恢复状态、充分利用缓存，让应用从后台"秒回"前台。

一、背景与动机

上一篇我们攻克了冷启动优化，把5秒的启动时间压缩到了1秒。但你知道吗？对于大多数应用来说，冷启动只占总启动次数的20%左右，剩下的80%都是热启动和温启动。换句话说，用户更常遇到的场景是：切到微信回条消息，再切回来——这时候应用能不能"秒回"，直接决定了日常使用体验。

热启动就像你从沙发上站起来去厨房——你不需要重新认识这个家（冷启动），只需要从上次停下的地方继续。但"继续"这件事说起来简单，做起来却有不少门道：状态保存了吗？缓存还有效吗？onForeground里的恢复逻辑够快吗？

本文将深入热启动的优化实战，从流程分析到状态管理，从缓存利用到性能监控，全方位提升应用从后台恢复到前台的速度。

二、核心原理

2.1 热启动流程分析

热启动的流程比冷启动简单得多——进程还在，Application已初始化，只需要将Ability从后台切回前台。但"简单"不等于"没有优化空间"：

flowchart TD
    classDef triggerStyle fill:#E8EAF6,stroke:#283593,stroke-width:2px,color:#1A237E
    classDef systemStyle fill:#E1F5FE,stroke:#0277BD,stroke-width:2px,color:#01579B
    classDef callbackStyle fill:#E8F5E9,stroke:#2E7D32,stroke-width:2px,color:#1B5E20
    classDef optimizeStyle fill:#FFF3E0,stroke:#E65100,stroke-width:2px,color:#BF360C
    classDef resultStyle fill:#FCE4EC,stroke:#C62828,stroke-width:2px,color:#B71C1C

    A([用户从后台切回应用]):::triggerStyle --> B[系统触发onForeground回调]:::systemStyle
    B --> C{是否有保存的状态?}:::systemStyle
    C -->|有| D[恢复UI状态]:::callbackStyle
    C -->|无| E[重新加载数据]:::optimizeStyle
    D --> F{缓存是否有效?}:::systemStyle
    E --> F
    F -->|有效| G[使用缓存数据渲染]:::callbackStyle
    F -->|过期| H[异步刷新数据]:::optimizeStyle
    G --> I[界面可交互]:::resultStyle
    H --> I
    
    B --> J[⚠️ onForeground中的耗时操作]:::optimizeStyle
    J --> J1[重新请求全部数据]:::optimizeStyle
    J --> J2[重建整个页面]:::optimizeStyle
    J --> J3[执行不必要的动画]:::optimizeStyle

2.2 热启动 vs 冷启动优化重点对比

三、代码实战

3.1 基础示例：onForeground恢复优化

很多应用在onForeground中做了太多不必要的工作，导致热启动比冷启动还慢。先看一个反面教材和优化方案：

// ❌ 优化前：onForeground中的"全量刷新"陷阱
import UIAbility from '@ohos.app.ability.UIAbility';
import hilog from '@ohos.hilog';

export default class EntryAbility extends UIAbility {
  private pageData: Map<string, Object> = new Map();

  onForeground(): void {
    // 灾难！每次回到前台都全量刷新
    this.reloadAllData();        // 重新请求所有数据 - 800ms
    this.refreshAllImages();     // 重新加载所有图片 - 500ms
    this.rebuildAllWidgets();    // 重建所有组件 - 300ms
    this.restartAnimations();    // 重启动画 - 100ms
    // 总耗时: 约1700ms ❌ 用户明显感知卡顿
  }

  private reloadAllData(): void {
    // 重新请求所有API数据...
  }
  private refreshAllImages(): void {
    // 重新加载所有图片...
  }
  private rebuildAllWidgets(): void {
    // 重建组件树...
  }
  private restartAnimations(): void {
    // 重启所有动画...
  }
}

// ✅ 优化后：onForeground中的"智能恢复"策略
import UIAbility from '@ohos.app.ability.UIAbility';
import hilog from '@ohos.hilog';

const TAG = 'HotStartOptimizer';
const DOMAIN = 0x0001;

export default class EntryAbility extends UIAbility {
  private pageData: Map<string, Object> = new Map();
  private lastForegroundTime: number = 0;  // 上次前台时间
  private dataCache: Map<string, { data: Object; timestamp: number }> = new Map();
  private static CACHE_TTL = 5 * 60 * 1000; // 缓存有效期5分钟

  onForeground(): void {
    const now = Date.now();
    const backgroundDuration = now - this.lastForegroundTime;
    hilog.info(DOMAIN, TAG, `从后台恢复，后台时长: ${backgroundDuration}ms`);

    // 根据后台时长决定恢复策略
    if (backgroundDuration < 30 * 1000) {
      // 后台不到30秒：直接恢复，不做任何刷新
      hilog.info(DOMAIN, TAG, '短时后台，直接恢复');
      return;
    } else if (backgroundDuration < 5 * 60 * 1000) {
      // 后台30秒~5分钟：增量刷新
      this.incrementalRefresh();
    } else {
      // 后台超过5分钟：全量刷新（但异步执行，不阻塞恢复）
      this.asyncFullRefresh();
    }
  }

  onBackground(): void {
    // 记录进入后台的时间
    this.lastForegroundTime = Date.now();
    // 保存当前页面状态
    this.saveCurrentState();
  }

  // 增量刷新：仅刷新可能过期的数据
  private async incrementalRefresh(): Promise<void> {
    hilog.info(DOMAIN, TAG, '执行增量刷新');
    
    // 检查缓存有效性，只刷新过期的数据
    for (const [key, cache] of this.dataCache) {
      const age = Date.now() - cache.timestamp;
      if (age > EntryAbility.CACHE_TTL) {
        hilog.info(DOMAIN, TAG, `缓存 ${key} 已过期，刷新`);
        await this.refreshSingleData(key);
      } else {
        hilog.info(DOMAIN, TAG, `缓存 ${key} 仍有效，跳过`);
      }
    }
  }

  // 异步全量刷新：不阻塞界面恢复
  private asyncFullRefresh(): void {
    hilog.info(DOMAIN, TAG, '执行异步全量刷新');
    
    // 先用缓存数据渲染界面，让用户立刻看到内容
    // 然后异步请求数据，请求完成后更新
    setTimeout(async () => {
      try {
        const freshData = await this.fetchAllData();
        this.updateUIWithFreshData(freshData);
      } catch (error) {
        hilog.error(DOMAIN, TAG, `全量刷新失败: ${JSON.stringify(error)}`);
      }
    }, 0);
  }

  // 保存当前状态
  private saveCurrentState(): void {
    // 保存关键UI状态到内存
    // 注意：这里仅保存到内存，进程被杀后会丢失
    // 需要持久化的状态应在onBackground中写入Preferences
  }

  private async refreshSingleData(key: string): Promise<void> {}
  private async fetchAllData(): Promise<Object> { return {}; }
  private updateUIWithFreshData(data: Object): void {}
}

3.2 进阶示例：状态保存与恢复策略

状态保存是热启动优化的基础——没有保存，就谈不上恢复。但保存什么、怎么保存、保存到哪里，都需要精心设计：

// StateManager.ets - 状态保存与恢复管理器
import hilog from '@ohos.hilog';
import dataPreferences from '@ohos.data.preferences';

const TAG = 'StateManager';
const DOMAIN = 0x0001;

/**
 * 状态存储层级
 */
enum StateStorageLevel {
  MEMORY = 'memory',       // 内存：最快，进程被杀即丢失
  PREFERENCES = 'prefs',   // 偏好设置：较快，持久化小数据
  FILE = 'file',           // 文件：较慢，持久化大数据
}

/**
 * 状态项定义
 */
interface StateItem {
  key: string;                          // 状态键名
  value: Object;                        // 状态值
  storageLevel: StateStorageLevel;      // 存储层级
  lastModified: number;                 // 最后修改时间
}

/**
 * 状态保存与恢复管理器
 * 分层存储策略：内存 → 偏好设置 → 文件
 */
export class StateManager {
  private static instance: StateManager;
  private memoryStore: Map<string, StateItem> = new Map();  // 内存存储
  private preferencesStore: dataPreferences.Preferences | null = null;
  private context: Context | null = null;

  private constructor() {}

  static getInstance(): StateManager {
    if (!StateManager.instance) {
      StateManager.instance = new StateManager();
    }
    return StateManager.instance;
  }

  // 初始化（在Application.onCreate中调用）
  async init(context: Context): Promise<void> {
    this.context = context;
    try {
      this.preferencesStore = await dataPreferences.getPreferences(context, 'app_state');
      hilog.info(DOMAIN, TAG, 'StateManager初始化完成');
    } catch (error) {
      hilog.error(DOMAIN, TAG, `StateManager初始化失败: ${JSON.stringify(error)}`);
    }
  }

  // 保存状态（在onBackground中调用）
  async saveState(key: string, value: Object, level: StateStorageLevel): Promise<void> {
    const item: StateItem = {
      key,
      value,
      storageLevel: level,
      lastModified: Date.now(),
    };

    // 始终保存到内存
    this.memoryStore.set(key, item);

    // 根据存储层级决定是否持久化
    switch (level) {
      case StateStorageLevel.PREFERENCES:
        if (this.preferencesStore) {
          await this.preferencesStore.put(key, JSON.stringify(value));
          await this.preferencesStore.flush();
        }
        break;
      case StateStorageLevel.FILE:
        // 大数据写入文件
        await this.writeToFile(key, value);
        break;
      default:
        // MEMORY级别仅存内存，不做持久化
        break;
    }

    hilog.info(DOMAIN, TAG, `状态已保存: ${key}, 层级: ${level}`);
  }

  // 恢复状态（在onForeground中调用）
  async restoreState<T>(key: string, defaultValue: T): Promise<T> {
    // 优先从内存恢复
    const memoryItem = this.memoryStore.get(key);
    if (memoryItem) {
      hilog.info(DOMAIN, TAG, `从内存恢复状态: ${key}`);
      return memoryItem.value as T;
    }

    // 内存中没有，尝试从偏好设置恢复
    if (this.preferencesStore) {
      try {
        const prefsValue = await this.preferencesStore.get(key, '');
        if (prefsValue && typeof prefsValue === 'string') {
          const parsed = JSON.parse(prefsValue) as T;
          // 回填内存缓存
          this.memoryStore.set(key, {
            key,
            value: parsed as Object,
            storageLevel: StateStorageLevel.PREFERENCES,
            lastModified: Date.now(),
          });
          hilog.info(DOMAIN, TAG, `从偏好设置恢复状态: ${key}`);
          return parsed;
        }
      } catch (error) {
        hilog.warn(DOMAIN, TAG, `偏好设置恢复失败: ${JSON.stringify(error)}`);
      }
    }

    // 都没有，返回默认值
    hilog.info(DOMAIN, TAG, `状态未找到，使用默认值: ${key}`);
    return defaultValue;
  }

  // 批量保存状态
  async saveBatch(states: Array<{ key: string; value: Object; level: StateStorageLevel }>): Promise<void> {
    const promises = states.map(s => this.saveState(s.key, s.value, s.level));
    await Promise.all(promises);
    hilog.info(DOMAIN, TAG, `批量保存 ${states.length} 个状态项`);
  }

  // 清除指定状态
  async clearState(key: string): Promise<void> {
    this.memoryStore.delete(key);
    if (this.preferencesStore) {
      await this.preferencesStore.delete(key);
      await this.preferencesStore.flush();
    }
  }

  // 写入文件（大数据持久化）
  private async writeToFile(key: string, value: Object): Promise<void> {
    if (!this.context) return;
    try {
      const dir = this.context.filesDir;
      const filePath = `${dir}/state_${key}.json`;
      const content = JSON.stringify(value);
      // 实际项目中使用fs.writeTextSync写入文件
      hilog.info(DOMAIN, TAG, `状态已写入文件: ${filePath}`);
    } catch (error) {
      hilog.error(DOMAIN, TAG, `文件写入失败: ${JSON.stringify(error)}`);
    }
  }
}

3.3 完整示例：热启动缓存利用与性能监控

将状态管理、缓存策略和性能监控整合，实现完整的热启动优化方案：

// HotStartOptimizer.ets - 热启动优化器（完整版）
import UIAbility from '@ohos.app.ability.UIAbility';
import hilog from '@ohos.hilog';

const TAG = 'HotStartOptimizer';
const DOMAIN = 0x0001;

/**
 * 缓存条目
 */
interface CacheEntry<T> {
  data: T;                // 缓存数据
  timestamp: number;      // 缓存时间
  ttl: number;            // 有效期(ms)
  version: string;        // 数据版本号
}

/**
 * 热启动性能指标
 */
interface HotStartMetrics {
  onForegroundStart: number;     // onForeground开始时间
  stateRestoreEnd: number;       // 状态恢复完成时间
  cacheHitEnd: number;           // 缓存命中完成时间
  uiReadyEnd: number;            // UI就绪时间
  totalDuration: number;         // 总耗时
  cacheHitRate: number;          // 缓存命中率
}

/**
 * 热启动优化器
 * 集成缓存管理、状态恢复、性能监控
 */
export class HotStartOptimizer {
  private static instance: HotStartOptimizer;
  private cache: Map<string, CacheEntry<Object>> = new Map();
  private metrics: HotStartMetrics | null = null;
  private lastBackgroundTime: number = 0;
  private stateSnapshot: Map<string, Object> = new Map();  // 状态快照

  // 缓存策略配置
  private cacheConfig: Map<string, number> = new Map([
    ['user_profile', 30 * 60 * 1000],     // 用户信息：30分钟
    ['feed_list', 5 * 60 * 1000],          // 信息流：5分钟
    ['config_data', 60 * 60 * 1000],       // 配置数据：1小时
    ['search_history', 24 * 60 * 60 * 1000], // 搜索历史：24小时
  ]);

  private constructor() {}

  static getInstance(): HotStartOptimizer {
    if (!HotStartOptimizer.instance) {
      HotStartOptimizer.instance = new HotStartOptimizer();
    }
    return HotStartOptimizer.instance;
  }

  // ========== 缓存管理 ==========

  // 写入缓存
  putCache<T>(key: string, data: T, customTtl?: number): void {
    const ttl = customTtl || this.cacheConfig.get(key) || 5 * 60 * 1000;
    this.cache.set(key, {
      data: data as Object,
      timestamp: Date.now(),
      ttl,
      version: `v_${Date.now()}`,
    });
    hilog.info(DOMAIN, TAG, `缓存写入: ${key}, TTL: ${ttl}ms`);
  }

  // 读取缓存
  getCache<T>(key: string): T | null {
    const entry = this.cache.get(key);
    if (!entry) {
      hilog.info(DOMAIN, TAG, `缓存未命中: ${key}`);
      return null;
    }

    // 检查是否过期
    const age = Date.now() - entry.timestamp;
    if (age > entry.ttl) {
      this.cache.delete(key);
      hilog.info(DOMAIN, TAG, `缓存已过期: ${key}, 存活: ${age}ms`);
      return null;
    }

    hilog.info(DOMAIN, TAG, `缓存命中: ${key}, 剩余: ${entry.ttl - age}ms`);
    return entry.data as T;
  }

  // 预热缓存（在后台空闲时调用）
  prewarmCache(keys: string[]): void {
    hilog.info(DOMAIN, TAG, `预热缓存: ${keys.join(', ')}`);
    // 检查即将过期的缓存，提前刷新
    for (const key of keys) {
      const entry = this.cache.get(key);
      if (entry) {
        const remaining = entry.ttl - (Date.now() - entry.timestamp);
        if (remaining < 60 * 1000) {
          // 不足1分钟过期，提前刷新
          hilog.info(DOMAIN, TAG, `缓存即将过期，提前刷新: ${key}`);
          this.refreshCacheEntry(key);
        }
      }
    }
  }

  // 刷新单个缓存条目
  private refreshCacheEntry(key: string): void {
    // 根据key从对应的数据源重新获取数据
    // 实际项目中这里会调用具体的API
    hilog.info(DOMAIN, TAG, `刷新缓存: ${key}`);
  }

  // ========== 状态快照 ==========

  // 保存状态快照（在onBackground中调用）
  saveSnapshot(state: Map<string, Object>): void {
    this.stateSnapshot = new Map(state);
    this.lastBackgroundTime = Date.now();
    hilog.info(DOMAIN, TAG, `状态快照已保存, ${state.size}个状态项`);
  }

  // 恢复状态快照（在onForeground中调用）
  restoreSnapshot(): Map<string, Object> | null {
    if (this.stateSnapshot.size === 0) {
      hilog.info(DOMAIN, TAG, '无状态快照可恢复');
      return null;
    }
    hilog.info(DOMAIN, TAG, `恢复状态快照, ${this.stateSnapshot.size}个状态项`);
    return new Map(this.stateSnapshot);
  }

  // ========== 性能监控 ==========

  // 开始记录热启动指标
  beginMetrics(): void {
    this.metrics = {
      onForegroundStart: Date.now(),
      stateRestoreEnd: 0,
      cacheHitEnd: 0,
      uiReadyEnd: 0,
      totalDuration: 0,
      cacheHitRate: 0,
    };
  }

  // 标记状态恢复完成
  markStateRestored(): void {
    if (this.metrics) {
      this.metrics.stateRestoreEnd = Date.now();
    }
  }

  // 标记缓存查询完成
  markCacheResolved(hitCount: number, totalCount: number): void {
    if (this.metrics) {
      this.metrics.cacheHitEnd = Date.now();
      this.metrics.cacheHitRate = totalCount > 0 ? hitCount / totalCount : 0;
    }
  }

  // 标记UI就绪
  markUIReady(): void {
    if (this.metrics) {
      this.metrics.uiReadyEnd = Date.now();
      this.metrics.totalDuration = this.metrics.uiReadyEnd - this.metrics.onForegroundStart;
      this.printMetrics();
    }
  }

  // 输出性能指标
  private printMetrics(): void {
    if (!this.metrics) return;
    const m = this.metrics;
    hilog.info(DOMAIN, TAG, '===== 热启动性能报告 =====');
    hilog.info(DOMAIN, TAG, `状态恢复耗时: ${m.stateRestoreEnd - m.onForegroundStart}ms`);
    hilog.info(DOMAIN, TAG, `缓存解析耗时: ${m.cacheHitEnd - m.stateRestoreEnd}ms`);
    hilog.info(DOMAIN, TAG, `UI就绪耗时: ${m.uiReadyEnd - m.cacheHitEnd}ms`);
    hilog.info(DOMAIN, TAG, `总耗时: ${m.totalDuration}ms`);
    hilog.info(DOMAIN, TAG, `缓存命中率: ${(m.cacheHitRate * 100).toFixed(1)}%`);
    hilog.info(DOMAIN, TAG, '===== 报告结束 =====');
  }
}

// ========== 在Ability中集成热启动优化 ==========
export default class OptimizedHotStartAbility extends UIAbility {
  private optimizer = HotStartOptimizer.getInstance();

  onForeground(): void {
    this.optimizer.beginMetrics();

    // 第1步：恢复状态快照
    const snapshot = this.optimizer.restoreSnapshot();
    if (snapshot) {
      this.applySnapshot(snapshot);
    }
    this.optimizer.markStateRestored();

    // 第2步：利用缓存渲染界面
    this.renderWithCache();
  }

  // 应用状态快照
  private applySnapshot(snapshot: Map<string, Object>): void {
    // 将快照中的状态应用到UI组件
    for (const [key, value] of snapshot) {
      hilog.info(DOMAIN, TAG, `恢复状态: ${key}`);
    }
  }

  // 使用缓存渲染界面
  private renderWithCache(): void {
    let hitCount = 0;
    let totalCount = 0;

    // 尝试从缓存获取关键数据
    const feedData = this.optimizer.getCache('feed_list');
    totalCount++;
    if (feedData) {
      hitCount++;
      // 用缓存数据直接渲染
      this.renderFeed(feedData);
    }

    const profileData = this.optimizer.getCache('user_profile');
    totalCount++;
    if (profileData) {
      hitCount++;
      this.renderProfile(profileData);
    }

    this.optimizer.markCacheResolved(hitCount, totalCount);

    // 异步刷新过期数据
    this.refreshStaleData();
  }

  private renderFeed(data: Object): void {}
  private renderProfile(data: Object): void {}
  private async refreshStaleData(): Promise<void> {
    // 异步刷新过期或缺失的数据
  }

  onBackground(): void {
    // 保存当前状态快照
    const currentState = this.collectCurrentState();
    this.optimizer.saveSnapshot(currentState);

    // 预热即将过期的缓存
    this.optimizer.prewarmCache(['feed_list', 'user_profile']);
  }

  // 收集当前状态
  private collectCurrentState(): Map<string, Object> {
    const state = new Map<string, Object>();
    // 收集需要保存的UI状态
    // 例如：滚动位置、选中tab、输入框内容等
    return state;
  }
}

四、踩坑与注意事项

坑点1：onForeground中执行同步IO操作

有些开发者在onForeground中同步读取文件或数据库，这在低端设备上可能导致几百毫秒的阻塞。解决方案：所有IO操作都应该异步执行，先展示缓存数据，IO完成后再更新。

坑点2：状态保存粒度过细导致性能下降

保存每一个UI组件的状态看似完善，但过多的状态项会导致序列化/反序列化开销增大。解决方案：只保存影响用户体验的关键状态（如滚动位置、选中tab），非关键状态可以丢弃后重建。

坑点3：缓存没有设置过期策略

缓存永远不过期，用户看到的是旧数据；缓存过期太快，热启动优化效果大打折扣。解决方案：根据数据特性设置不同的TTL——用户信息30分钟、信息流5分钟、配置数据1小时，并在后台空闲时提前刷新即将过期的缓存。

坑点4：忽略进程被杀后的温启动场景

热启动的前提是进程还在，但系统在内存不足时会杀掉后台进程，此时用户切回应用走的是温启动（需要重建Ability但Application已初始化）。如果你的状态只保存在内存中，温启动时就丢失了。解决方案：关键状态同时保存到Preferences，确保温启动也能恢复。

坑点5：onBackground中执行耗时操作

onBackground的执行时间有限（约1~2秒），如果在里面做了太多保存操作，可能还没保存完就被系统挂起了。解决方案：onBackground中只做最关键的内存级状态保存，持久化操作放到后台任务中异步执行。

坑点6：热启动时强制刷新所有数据

有些应用为了确保数据最新，每次onForeground都强制刷新所有数据。这就像你只是去客厅拿个遥控器，回来后发现整个房间被重新装修了一遍——虽然是最新的，但完全不必要。解决方案：根据后台时长和缓存TTL智能决定是否刷新，短时后台直接恢复，长时后台异步刷新。

坑点7：未处理网络状态变化

用户在后台可能切换了网络（WiFi↔移动数据），如果热启动时没有感知网络变化，可能导致请求失败或使用了错误网络策略。解决方案：在onForeground中检查当前网络状态，必要时调整请求策略。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. onBackground超时限制：HarmonyOS 6严格限制onBackground执行时间为2秒，超时将强制挂起
2. 后台进程回收更激进：低内存时系统更积极地回收后台进程，温启动场景增多
3. 状态保存自动序列化：SavedState框架自动处理状态序列化和版本兼容

适配代码

// HarmonyOS 6 热启动适配 - 利用SavedState框架
import UIAbility from '@ohos.app.ability.UIAbility';
import SavedState from '@ohos.app.ability.SavedState';

export default class HarmonyOS6HotStartAbility extends UIAbility {
  // HarmonyOS 6新增的状态保存回调
  onSaveState(outState: SavedState): void {
    // 使用系统级SavedState框架保存状态
    outState.putString('current_tab', 'home');
    outState.putInt('scroll_position', 256);
    outState.putBoolean('is_refreshing', false);
    outState.putStringArray('loaded_ids', ['1', '2', '3']);
  }

  // HarmonyOS 6新增的状态恢复回调
  onRestoreState(inState: SavedState): void {
    // 从SavedState恢复状态
    const currentTab = inState.getString('current_tab', 'home');
    const scrollPos = inState.getInt('scroll_position', 0);
    const isRefreshing = inState.getBoolean('is_refreshing', false);
    const loadedIds = inState.getStringArray('loaded_ids', []);
    
    hilog.info(DOMAIN, TAG, `恢复状态: tab=${currentTab}, scroll=${scrollPos}`);
  }

  // HarmonyOS 6的onForeground新增want参数
  onForeground(want?): void {
    if (want) {
      // 可以从want中获取恢复意图
      const action = want.action;
      hilog.info(DOMAIN, TAG, `前台恢复意图: ${action}`);
    }
    
    // 利用AppCache获取缓存数据
    this.restoreWithAppCache();
  }

  private restoreWithAppCache(): void {
    // 使用HarmonyOS 6的AppCache框架
    // 系统自动管理缓存生命周期和淘汰策略
  }
}

六、总结

三维度评价表

一句话总结：热启动优化的核心是"让回来比离开更快"——通过智能缓存、分层状态保存、按需刷新，让用户从后台切回应用时感受不到任何延迟。

下篇预告：《HarmonyOS APP开发：资源预加载与启动预加载策略》——预加载是启动优化的"提前量"策略，在用户还没到达之前就把资源准备好，敬请期待！