文章目录

在这里插入图片描述

每日一句正能量

今天不经意间装入的一项技能，也许会在未来的某段人生道路上，悄然为你搭起一座桥。
很多时候我们学东西，当下看不到用处。但人生的奇妙之处在于，你不知道哪个“无用之用”会在哪个节点变成唯一的通路。保持对“当下看似无意义之事”的敬畏。

一、前言：为什么页面栈管理是性能优化的第一道防线？

在 HarmonyOS 应用开发中，页面跳转是最频繁的操作之一。每一次 router.pushUrl() 都会在页面栈中压入一个新的页面实例，每一次 router.back() 都会弹出栈顶页面。如果开发者对页面栈的增长规律缺乏认知，任由页面实例无限制累积，很快就会触及 HarmonyOS 页面栈 32 页的上限，导致应用崩溃或异常行为。

更隐蔽的问题是内存泄漏。页面虽然从栈中弹出，但如果页面内的定时器仍在运行、EventHub 监听未注销、网络连接未关闭，页面实例实际上仍被这些"活引用"持有，无法被垃圾回收。长此以往，应用内存持续攀升，最终触发系统 OOM（Out of Memory） killer，用户体验断崖式下跌。

本文将从页面栈管理机制出发，系统讲解 Standard/Single 两种实例模式的差异、页面生命周期的完整流程、资源释放的最佳实践，以及 LRUCache、PurgeableMemory、onMemoryLevel 等内存优化工具的使用方法，帮助开发者建立一套完整的页面栈管理与内存治理体系。

二、页面栈管理机制：理解 HarmonyOS 的路由内核

2.1 页面栈的基本概念

HarmonyOS 的页面路由基于栈（Stack）数据结构实现。每个 UIAbility 维护一个独立的页面栈，栈中保存的是 @Entry 装饰的页面组件实例。页面栈遵循"后进先出"（LIFO）原则：

  • router.pushUrl()：将目标页面压入栈顶，当前页面被隐藏但仍保留在栈中
  • router.replaceUrl()：用目标页面替换当前页面，当前页面被销毁并从栈中移除
  • router.back()：弹出栈顶页面，返回到下一个页面
  • router.clear()：清空整个页面栈，释放所有页面占用的内存

在这里插入图片描述

页面栈的最大容量为 32 个页面。当栈深度达到上限后，继续调用 pushUrl() 不会创建新页面，而是可能导致应用异常。因此，对于页面流转复杂的应用（如电商的"首页→列表→详情→购物车→结算→支付→结果"流程），必须主动管理页面栈深度，及时清理不再需要的页面。

2.2 页面栈与内存的关系

页面栈中的每个页面实例都占用内存，主要包括：

内存占用项 说明 释放时机
页面组件树 @Entry 组件及其子组件的 UI 节点 页面从栈中弹出且组件销毁
状态变量 @State、@StorageLink 等绑定的数据 组件销毁时释放（PersistentStorage 除外）
图片缓存 Image 组件加载的图片数据 组件销毁时释放（全局缓存除外）
网络连接 NetConnection、HTTP 请求等 需手动在 aboutToDisappear 中关闭
定时器/监听 setInterval、EventHub.on 等 需手动在 aboutToDisappear 中注销
全局缓存 LRUCache、AppStorage 中的数据 需设置上限或手动清理

关键认知：页面从栈中弹出 ≠ 内存立即释放。如果页面内的异步任务、事件监听、定时器等仍在运行，页面实例会被这些"活引用"持有，导致内存泄漏。

三、Standard 与 Single 模式：两种实例策略的深度对比

HarmonyOS 路由提供了两种实例模式，决定了目标页面 URL 是否会对应多个实例：

3.1 Standard 模式（默认）：多实例模式

router.pushUrl({
  url: 'pages/DetailPage',
  params: { id: '123' }
}, router.RouterMode.Standard); // 默认模式，可省略

行为特征：无论页面栈中是否已存在相同 URL 的页面，每次调用 pushUrl() 都会创建一个新的页面实例并压入栈顶。

适用场景：

  • 商品详情页：不同商品需要独立的页面实例
  • 订单确认页：每次下单都是全新的流程
  • 搜索结果页：不同关键词需要独立的结果页

内存影响：页面栈持续增长，需要开发者主动控制栈深度，避免达到 32 页上限。

3.2 Single 模式：单实例复用

router.pushUrl({
  url: 'pages/HomePage',
  params: { tab: 'recommend' }
}, router.RouterMode.Single);

行为特征：如果页面栈中已存在相同 URL 的页面，系统会将离栈顶最近的同 URL 页面移动到栈顶，复用已有实例，不会创建新实例。

适用场景：

  • 首页：从任何页面返回首页时，复用已有的首页实例
  • 个人中心：状态需要保持的页面
  • 设置页：配置项修改后需要保留状态的页面

内存影响：有效控制页面栈深度，减少内存占用。但需要注意，Single 模式移动页面时不会触发 aboutToAppear，需要通过 onPageShow 刷新数据。

在这里插入图片描述

3.3 混合使用策略

在实际项目中，建议根据页面语义混合使用两种模式：

// 工具类封装
export class RouterHelper {
  // 需要全新实例的页面（详情、表单、结果页）
  static pushStandard(url: string, params?: object): void {
    router.pushUrl({ url, params }, router.RouterMode.Standard);
  }

  // 需要复用实例的页面（首页、个人中心、设置页）
  static pushSingle(url: string, params?: object): void {
    router.pushUrl({ url, params }, router.RouterMode.Single);
  }

  // 替换当前页（释放当前页内存）
  static replace(url: string, params?: object): void {
    router.replaceUrl({ url, params });
  }

  // 返回首页并清理中间页面
  static backToHome(): void {
    router.clear();
    router.pushUrl({ url: 'pages/Index' });
  }
}

四、页面生命周期：掌握资源管理的精确时机

HarmonyOS 的页面生命周期分为页面级和组件级两套体系，理解它们的触发时机是做好内存管理的前提。

4.1 生命周期完整流程

在这里插入图片描述

页面级生命周期（仅 @Entry 组件可用）：

生命周期 触发时机 典型操作
onPageShow 页面每次显示时（路由跳转/应用回到前台） 加载页面数据、启动动画、恢复后台任务
onPageHide 页面每次隐藏时（路由跳转/应用进入后台） 暂停动画、暂停网络请求、保存页面状态
onBackPress 用户点击返回键时 拦截返回逻辑、弹出确认对话框

组件级生命周期（所有 @Component 组件都有）：

生命周期 触发时机 典型操作
aboutToAppear 组件 build() 之前 初始化状态、注册监听、创建资源
onDidBuild 组件 build() 之后 埋点上报、非 UI 操作
aboutToDisappear 组件即将销毁时 释放资源、注销监听、关闭连接

4.2 不同路由操作的生命周期差异

理解不同路由操作触发的生命周期差异，对于精确控制资源至关重要：

场景一：pushUrl A → B

页面A: onPageHide
页面B: aboutToAppear → build → onPageShow

页面 A 被隐藏但未被销毁，其资源仍然保留在内存中。如果 A 中有定时器或网络请求，会继续运行。

场景二：back B → A

页面B: onPageHide → aboutToDisappear
页面A: onPageShow

页面 B 被销毁，必须在 aboutToDisappear 中释放所有资源。页面 A 重新显示，通过 onPageShow 恢复状态。

场景三：replaceUrl A → B

页面A: onPageHide → aboutToDisappear
页面B: aboutToAppear → build → onPageShow

页面 A 被直接替换并销毁，与 back 不同，A 不会保留在栈中。这是释放中间页面内存的最佳方式。

场景四：Home 键后台

当前页: onPageHide
(不触发 aboutToDisappear，页面仍在内存中)

应用回到前台时：

当前页: onPageShow

4.3 生命周期最佳实践

@Entry
@Component
struct DetailPage {
  @State productId: string = '';
  @State productData: ProductModel | null = null;
  private refreshTimer: number = -1;
  private netCon: connection.NetConnection | null = null;
  private eventCallback: (data: object) => void = () => {};

  // ========== 资源创建阶段 ==========
  aboutToAppear(): void {
    // 1. 初始化状态
    const params = router.getParams() as Record<string, string>;
    this.productId = params['id'] || '';

    // 2. 注册事件监听
    this.eventCallback = (data: object) => {
      this.handleFavoriteChanged(data);
    };
    getContext(this).eventHub.on('favoriteChanged', this.eventCallback);

    // 3. 创建网络连接
    this.netCon = connection.createNetConnection();
    this.netCon.register((err) => {
      if (!err) console.info('网络监听注册成功');
    });

    // 4. 启动定时刷新（每30秒）
    this.refreshTimer = setInterval(() => {
      this.refreshProductData();
    }, 30000);
  }

  onPageShow(): void {
    // 页面显示时加载数据
    this.loadProductData();
  }

  // ========== 资源释放阶段（关键！）==========
  onPageHide(): void {
    // 页面隐藏时暂停非必要任务
    console.info('页面隐藏，暂停后台刷新');
  }

  aboutToDisappear(): void {
    // 1. 注销事件监听（防止内存泄漏）
    getContext(this).eventHub.off('favoriteChanged', this.eventCallback);

    // 2. 清除定时器（防止页面销毁后仍触发回调）
    if (this.refreshTimer !== -1) {
      clearInterval(this.refreshTimer);
      this.refreshTimer = -1;
    }

    // 3. 关闭网络连接
    if (this.netCon) {
      this.netCon.unregister((err) => {
        if (!err) console.info('网络监听注销成功');
      });
      this.netCon = null;
    }

    // 4. 释放大对象引用
    this.productData = null;
  }

  private loadProductData(): void {
    // 加载商品数据...
  }

  private refreshProductData(): void {
    // 刷新商品数据...
  }

  private handleFavoriteChanged(data: object): void {
    // 处理收藏状态变化...
  }

  build() {
    Column() {
      // UI 构建...
    }
  }
}

核心原则：

  1. 成对原则：aboutToAppear 中创建的资源，必须在 aboutToDisappear 中释放
  2. 引用保存原则：注册监听时保存回调函数的引用，注销时使用相同的引用
  3. 判空原则：释放资源前检查对象是否存在，避免重复释放导致异常
  4. 置空原则：释放后将引用置为 null，帮助垃圾回收器识别可回收对象

五、内存泄漏排查与治理实战

5.1 常见内存泄漏场景

泄漏场景 原因 检测方法 修复方案
定时器未清除 setInterval/setTimeout 在页面销毁后仍运行 页面反复进出后内存持续增长 aboutToDisappear 中 clearInterval
事件监听未注销 EventHub.on/Emitter.on 未对应 off 收到已销毁页面的回调日志 aboutToDisappear 中 off
网络连接未关闭 NetConnection 未 unregister 网络状态变更时收到已销毁页面的回调 aboutToDisappear 中关闭连接
闭包持有页面引用 异步回调闭包中使用了 this 页面销毁后异步结果仍触发 UI 更新 使用 PageAliveGuard 判断页面状态
全局缓存无限增长 LRUCache 未设置容量上限 缓存对象数量持续增加 设置 maxCapacity 并定期清理
图片缓存未释放 大图加载后未释放 图片列表页内存占用高 使用 syncLoad + 组件销毁释放

5.2 Disposable 模式：统一资源管理

对于复杂的页面，建议引入 Disposable 模式统一管理可释放资源：

// utils/Disposable.ets
export interface Disposable {
  dispose(): void;
}

export class DisposableBucket implements Disposable {
  private disposables: Disposable[] = [];

  add(disposable: Disposable): void {
    this.disposables.push(disposable);
  }

  clear(): void {
    this.disposables.forEach(d => {
      try {
        d.dispose();
      } catch (e) {
        console.error('释放资源失败:', e);
      }
    });
    this.disposables = [];
  }

  dispose(): void {
    this.clear();
  }
}

// 定时器包装器
export class TimerDisposable implements Disposable {
  constructor(private timerId: number) {}
  dispose(): void {
    clearInterval(this.timerId);
  }
}

// 事件监听包装器
export class EventHubDisposable implements Disposable {
  constructor(
    private context: Context,
    private event: string,
    private callback: Function
  ) {}
  dispose(): void {
    this.context.eventHub.off(this.event, this.callback);
  }
}

// 网络连接包装器
export class NetConnectionDisposable implements Disposable {
  constructor(private netCon: connection.NetConnection | null) {}
  dispose(): void {
    if (this.netCon) {
      this.netCon.unregister();
    }
  }
}

页面中使用：

@Entry
@Component
struct SafePage {
  private disposables: DisposableBucket = new DisposableBucket();

  aboutToAppear(): void {
    // 注册定时器
    const timerId = setInterval(() => this.refresh(), 30000);
    this.disposables.add(new TimerDisposable(timerId));

    // 注册事件监听
    const callback = (data: object) => this.handleEvent(data);
    getContext(this).eventHub.on('update', callback);
    this.disposables.add(
      new EventHubDisposable(getContext(this), 'update', callback)
    );

    // 注册网络连接
    const netCon = connection.createNetConnection();
    netCon.register();
    this.disposables.add(new NetConnectionDisposable(netCon));
  }

  aboutToDisappear(): void {
    // 一行代码释放所有资源
    this.disposables.dispose();
  }

  private refresh(): void { /* ... */ }
  private handleEvent(data: object): void { /* ... */ }

  build() { /* ... */ }
}

5.3 异步任务的页面存活保护

当页面发起异步请求后，如果用户在请求完成前离开页面，返回的数据不应再更新已销毁页面的 UI：

@Entry
@Component
struct AsyncPage {
  @State data: string = '';
  private isAlive: boolean = true;

  aboutToAppear(): void {
    this.isAlive = true;
    this.fetchData();
  }

  aboutToDisappear(): void {
    this.isAlive = false;
  }

  private async fetchData(): Promise<void> {
    try {
      const result = await httpRequest('https://api.example.com/data');
      // 页面已销毁时不更新 UI
      if (this.isAlive) {
        this.data = result;
      }
    } catch (e) {
      if (this.isAlive) {
        console.error('请求失败:', e);
      }
    }
  }

  build() {
    Column() {
      Text(this.data)
    }
  }
}

六、LRUCache 与缓存优化策略

6.1 LRUCache 原理与使用

LRUCache（Least Recently Used Cache）是 HarmonyOS 提供的基于最近最少使用算法的缓存工具，当缓存空间不足时自动淘汰最久未访问的数据。

import { util } from '@kit.ArkTS';

// 创建容量为 50 的 LRUCache
const imageCache = new util.LRUCache<string, image.PixelMap>(50);

// 添加缓存
imageCache.put('img_123', pixelMap);

// 获取缓存（访问后自动移到链表尾部，标记为"最近使用"）
const cached = imageCache.get('img_123');
if (cached) {
  // 使用缓存的图片
}

// 删除指定缓存
imageCache.remove('img_123');

// 动态调整容量（新容量小于原容量时，自动淘汰多余数据）
imageCache.updateCapacity(30);

// 清空缓存
imageCache.clear();

LRUCache 核心方法：

方法 说明
put(key, value) 添加缓存，达到容量上限时淘汰头部（最久未用）数据
get(key) 查询缓存，命中后移至尾部（标记最近使用），未命中返回 undefined
remove(key) 删除指定缓存
updateCapacity(n) 调整容量上限
clear() 清空所有缓存
length 获取当前缓存数量

6.2 图片缓存优化实战

图片是应用内存占用的大户，合理的图片缓存策略可以显著降低内存压力：

import { image } from '@kit.ImageKit';
import { util } from '@kit.ArkTS';

class ImageCacheManager {
  private static instance: ImageCacheManager;
  private cache: util.LRUCache<string, image.PixelMap>;
  private readonly MAX_CACHE_SIZE = 30; // 最多缓存30张图片
  private readonly MAX_IMAGE_WIDTH = 1080; // 最大宽度限制

  private constructor() {
    this.cache = new util.LRUCache<string, image.PixelMap>(this.MAX_CACHE_SIZE);
  }

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

  // 加载图片并缓存（带尺寸限制）
  async loadImage(url: string, targetWidth: number = 0): Promise<image.PixelMap | undefined> {
    // 先查缓存
    const cached = this.cache.get(url);
    if (cached) {
      return cached;
    }

    // 下载图片
    const pixelMap = await this.downloadAndDecode(url, targetWidth);
    if (pixelMap) {
      this.cache.put(url, pixelMap);
    }
    return pixelMap;
  }

  private async downloadAndDecode(
    url: string, 
    targetWidth: number
  ): Promise<image.PixelMap | undefined> {
    // 下载图片数据...
    // 如果图片宽度超过限制，进行降采样
    // 返回处理后的 PixelMap
    return undefined;
  }

  // 清理缓存（低内存时调用）
  clearCache(): void {
    this.cache.clear();
  }

  // 获取当前缓存统计
  getStats(): { count: number; capacity: number } {
    return {
      count: this.cache.length,
      capacity: this.MAX_CACHE_SIZE
    };
  }
}

图片优化 checklist：

  1. 尺寸匹配：加载的图片尺寸应与显示组件大小一致，避免"大图画小框"
  2. 降采样：对于超大图（如相机原图），使用 image.createImageSource().createPixelMap() 的 decodingOptions 参数指定目标尺寸
  3. 懒加载：列表中的图片使用 LazyForEach 配合 cachedCount 控制预加载数量
  4. 格式选择：优先使用压缩率更高的格式（如 WebP），减少内存占用
  5. 及时释放：页面销毁时清理页面级图片缓存

七、系统内存监听与动态降级

7.1 onMemoryLevel：感知系统内存压力

HarmonyOS 提供了 onMemoryLevel() 接口，允许应用监听系统内存变化，在内存紧张时主动释放资源，避免被系统强制回收。

import { AbilityConstant } from '@kit.AbilityKit';

export default class EntryAbility extends UIAbility {
  onMemoryLevel(level: AbilityConstant.MemoryLevel): void {
    switch (level) {
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_MODERATE:
        // 内存适中：清理非必要缓存
        console.info('内存适中，清理过期缓存');
        ImageCacheManager.getInstance().clearCache();
        break;

      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_LOW:
        // 内存较低：释放更多资源
        console.info('内存较低，释放图片缓存和临时数据');
        ImageCacheManager.getInstance().clearCache();
        // 释放其他临时资源...
        break;

      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_CRITICAL:
        // 内存危急：尽最大努力释放资源
        console.info('内存危急，释放所有可释放资源');
        ImageCacheManager.getInstance().clearCache();
        // 暂停后台任务、降低图片质量等...
        break;

      default:
        break;
    }
  }
}

内存等级说明：

等级 值 建议操作
MEMORY_LEVEL_MODERATE 0 清理过期缓存、释放非必要资源
MEMORY_LEVEL_LOW 1 释放图片缓存、暂停后台任务、降低动画质量
MEMORY_LEVEL_CRITICAL 2 释放所有可释放资源、停止非核心功能、提示用户

7.2 PurgeableMemory：C++ 层的大对象治理

对于 C++ 层的大对象（如游戏纹理、大型数据集），HarmonyOS 提供了 PurgeableMemory 机制，允许系统在内存紧张时自动回收这些对象，需要时再重新创建。

// CMakeLists.txt
add_library(entry SHARED napi_init.cpp)
target_link_libraries(entry PUBLIC 
  libace_napi.z.so 
  libpurgeable_memory_ndk.z.so
)

// napi_init.cpp
#include "purgeable_memory.h"

// 创建 PurgeableMemory 对象
OH_PurgeableMemory* CreateLargeBuffer(size_t size) {
  // 重建函数：内存被回收后，系统会调用此函数重新创建数据
  auto rebuildFunc = [](void* param) -> bool {
    // 重新加载或生成数据
    return true;
  };

  OH_PurgeableMemory* mem = OH_PurgeableMemory_Create(
    size,           // 数据大小
    rebuildFunc,    // 重建函数
    nullptr         // 用户参数
  );
  return mem;
}

// 读取数据
void ReadData(OH_PurgeableMemory* mem) {
  // 开始读取
  if (OH_PurgeableMemory_BeginRead(mem)) {
    void* data = OH_PurgeableMemory_GetContent(mem);
    // 使用数据...
    
    // 读取完成
    OH_PurgeableMemory_EndRead(mem);
  }
}

// 修改数据
void WriteData(OH_PurgeableMemory* mem) {
  // 开始写入
  if (OH_PurgeableMemory_BeginWrite(mem)) {
    void* data = OH_PurgeableMemory_GetContent(mem);
    // 修改数据...
    
    // 更新重建规则
    OH_PurgeableMemory_AppendModify(mem, nullptr);
    
    // 写入完成
    OH_PurgeableMemory_EndWrite(mem);
  }
}

八、内存优化工具链与排查方法

在这里插入图片描述

8.1 DevEco Studio Profiler

DevEco Studio 内置的 Profiler 工具是内存排查的首选：

  1. Allocation Tracker：记录对象的分配栈，定位内存分配热点
  2. Heap Snapshot：抓取堆内存快照，分析对象引用关系
  3. Memory Timeline：实时展示内存占用曲线，识别异常增长

使用步骤：

  1. 连接真机或启动模拟器
  2. 打开 Profiler → Memory 面板
  3. 执行复现路径（如反复进入/退出页面 20 次）
  4. 观察内存曲线是否持续增长
  5. 抓取 Heap Snapshot，分析未被回收的对象及其引用链

8.2 HiLog 日志分析

在关键位置插入内存日志，帮助定位问题：

import { hilog } from '@kit.PerformanceAnalysisKit';

// 页面进入时记录
aboutToAppear(): void {
  hilog.info(0x0000, 'MemoryTrace', 
    `Page ${this.constructor.name} created, stack depth: ${router.getLength()}`);
}

// 页面销毁时记录
aboutToDisappear(): void {
  hilog.info(0x0000, 'MemoryTrace', 
    `Page ${this.constructor.name} destroyed, stack depth: ${router.getLength()}`);
}

// 缓存操作时记录
putToCache(key: string, size: number): void {
  hilog.info(0x0000, 'MemoryTrace', 
    `Cache put: ${key}, size: ${size}KB, total: ${this.getCacheSize()}KB`);
}

8.3 hdc shell 命令行工具

# 查看应用内存占用
hdc shell hidumper -s Memory

# 查看指定进程的内存详情
hdc shell hidumper -s Memory -a pid=12345

# 查看页面栈信息
hdc shell hidumper -s WindowManager

# 触发垃圾回收（调试用）
hdc shell cmd activity memory-factor critical

九、最佳实践总结

9.1 页面栈管理十大原则

  1. 控制栈深度：复杂流程及时使用 router.clear() 或 replaceUrl() 清理中间页面
  2. 合理选择模式：首页/个人中心用 Single 模式，详情/表单页用 Standard 模式
  3. 避免循环压栈：A→B→A 的场景使用 Single 模式或 back() 而非 pushUrl()
  4. 结算流程优化：支付完成后使用 replaceUrl() 跳转到结果页，释放支付页内存
  5. 全局返回首页：提供"返回首页"功能时使用 router.clear() + pushUrl()

9.2 内存治理十大原则

  1. 成对注册注销：EventHub/Emitter 的 on 必须有对应的 off
  2. 定时器必清除：所有 setInterval/setTimeout 在 aboutToDisappear 中清除
  3. 连接必关闭：网络连接、数据库连接、文件句柄必须显式关闭
  4. 缓存设上限：所有缓存（LRUCache、图片缓存）必须设置容量上限
  5. 大对象慎用：避免在内存中保存原始尺寸图片或大型数据集
  6. 异步加保护：异步回调中判断页面是否仍存活，避免更新已销毁页面
  7. 使用 Disposable：复杂页面引入 Disposable 模式统一管理资源
  8. 监听系统内存：实现 onMemoryLevel 在内存紧张时主动释放资源
  9. 定期 Profile：发版前使用 Profiler 执行固定复现路径，对比内存变化
  10. 日志留痕：在关键生命周期和缓存操作中插入 HiLog，便于线上问题排查

十、总结

本文从 HarmonyOS 页面栈管理机制出发，系统讲解了 Standard/Single 两种实例模式的差异与选型策略，深入剖析了页面生命周期的完整流程和不同路由操作触发的生命周期差异，提供了基于 Disposable 模式的统一资源管理方案，以及 LRUCache、PurgeableMemory、onMemoryLevel 等内存优化工具的实战用法。

页面栈管理与内存优化不是一次性的工作，而是需要贯穿整个应用生命周期的工程实践。只有将"谁注册、谁释放；谁缓存、谁设上限；谁异步、谁判断存活"的原则固化为团队开发规范，才能真正避免内存泄漏成为每次发版前的隐患。希望本文的架构思路和代码实践，能够帮助开发者在鸿蒙应用中构建出高性能、低内存占用的稳定系统。

转载自：https://blog.csdn.net/u014727709/article/details/163307749
欢迎 👍点赞✍评论⭐收藏，欢迎指正

Logo
HarmonyOS开发者社区

讨论HarmonyOS开发技术，专注于API与组件、DevEco Studio、测试、元服务和应用上架分发等。

更多推荐

cover

HarmonyOS 悬浮页签遮住内容怎么办：safeArea、滚动吸顶和折叠屏断点怎么拆

avatar HarmonyOS开发者社区
cover

光语助手（LuminaAssist）：基于 HarmonyOS 端云双态架构的多模态智能助理——面向视障与高龄用户的 AI 无障碍解决方案

avatar HarmonyOS开发者社区
cover

HarmonyOS 互动卡片刷新太频繁怎么办：FormExtensionAbility、用户触发和缓存兜底怎么拆

avatar HarmonyOS开发者社区