HarmonyOS APP开发：内存压缩与内存紧张处理

📌 核心要点：掌握onMemoryLevel回调的分级处理策略，实现数据压缩、资源按需释放、低内存设备适配三大核心能力，让你的应用在"内存饥荒"中依然从容运行。

一、背景与动机

你有没有想过，为什么同一个应用在8GB内存的旗舰机上丝般顺滑，在2GB的入门机上却卡成幻灯片？答案很简单——内存不够了。但"不够"不是终点，而是优化的起点。

内存紧张处理和OOM防范虽然相关，但侧重点不同：OOM防范关注的是"如何避免崩溃"，而内存紧张处理关注的是"如何在有限内存下保持可用性"。打个比方，OOM防范是"如何不饿死"，内存紧张处理是"如何在粮食短缺时依然吃得健康"。

在HarmonyOS生态中，内存紧张是常态而非例外。智能手表可能只有512MB内存，入门手机2GB，而且系统本身就要占用相当一部分。你的应用能分到的内存可能只有几百MB，甚至更少。如果代码不针对内存紧张做优化，那么：

1. 低端设备直接出局：应用在2GB设备上频繁卡顿甚至崩溃
2. 后台存活率低：用户切换应用后，你的应用被系统杀掉的概率大增
3. 多窗口体验差：在分屏模式下，两个应用共享有限的内存空间

本文将从内存紧张场景分析入手，构建从回调处理到资源压缩的完整优化体系。我们的目标是：让应用在512MB内存的设备上也能基本可用，在8GB内存的设备上则充分利用资源提供最佳体验。

二、核心原理

2.1 内存紧张场景分析

flowchart TD
    A[内存紧张场景] --> B[设备内存低]
    A --> C[系统内存压力大]
    A --> D[应用自身占用高]
    A --> E[多任务竞争]

    B --> B1[入门手机 <2GB]
    B --> B2[智能手表 <1GB]
    B --> B3[老旧设备内存衰减]

    C --> C1[后台应用过多]
    C --> C2[系统服务占用高]
    C --> C3[其他应用内存泄漏]

    D --> D1[缓存未限制]
    D --> D2[图片未压缩]
    D --> D3[大对象未释放]

    E --> E1[分屏模式]
    E --> E2[悬浮窗]
    E --> E3[后台同步任务]

    classDef rootStyle fill:#E53935,stroke:#B71C1C,stroke-width:3px,color:#FFF
    classDef sceneStyle fill:#FF8A65,stroke:#D84315,stroke-width:2px,color:#000
    classDef detailStyle fill:#FFCCBC,stroke:#BF360C,stroke-width:2px,color:#000

    class A rootStyle
    class B,C,D,E sceneStyle
    class B1,B2,B3,C1,C2,C3,D1,D2,D3,E1,E2,E3 detailStyle

2.2 内存紧张处理策略

flowchart LR
    A[系统内存压力回调] --> B{压力级别}
    B -->|MODERATE| C[轻度优化]
    B -->|LOW| D[中度优化]
    B -->|CRITICAL| E[重度优化]

    C --> C1[缩减缓存50%]
    C --> C2[释放闲置资源]
    C --> C3[降低预加载量]

    D --> D1[清空非关键缓存]
    D --> D2[降低图片质量]
    D --> D3[停止后台任务]
    D --> D4[压缩内存数据]

    E --> E1[清空所有缓存]
    E --> E2[关闭动画效果]
    E --> E3[进入极简模式]
    E --> E4[释放所有可选资源]

    classDef callbackStyle fill:#7E57C2,stroke:#4527A0,stroke-width:3px,color:#FFF
    classDef levelStyle fill:#CE93D8,stroke:#7B1FA2,stroke-width:2px,color:#000
    classDef actionStyle fill:#E1BEE7,stroke:#6A1B9A,stroke-width:2px,color:#000

    class A,B callbackStyle
    class C,D,E levelStyle
    class C1,C2,C3,D1,D2,D3,D4,E1,E2,E3,E4 actionStyle

处理内存紧张的关键在于"分级响应"——不同级别的压力采取不同力度的措施。就像医生看病，轻症开药、重症住院、危症进ICU，不能一刀切。过度优化（在内存充裕时也激进释放）会损害用户体验，而优化不足（在内存紧张时还大手大脚）则会导致崩溃。

三、代码实战

3.1 基础：onMemoryLevel回调处理

onMemoryLevel是HarmonyOS提供的系统级内存压力回调，是内存紧张处理的"第一道防线"。

import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';
import { hidebug } from '@kit.BasicServicesKit';

// 内存紧张级别枚举（便于理解）
const MEMORY_LEVEL = {
  NORMAL: -1,       // 正常（无回调）
  MODERATE: 0,      // 适度紧张
  LOW: 1,           // 严重紧张
  CRITICAL: 2       // 极度紧张（HarmonyOS 6新增）
};

// 内存紧张处理器
class MemoryTensionHandler {
  private currentLevel: number = MEMORY_LEVEL.NORMAL;
  private resourceRegistry: Map<string, () => number> = new Map();  // 资源注册表：名称→释放函数（返回释放的KB数）
  private totalReleased: number = 0;  // 累计释放的内存（KB）

  // 注册可释放资源
  registerResource(name: string, releaseFn: () => number): void {
    this.resourceRegistry.set(name, releaseFn);
    console.info(`[TensionHandler] 注册资源: ${name}`);
  }

  // 处理内存压力回调
  handleMemoryLevel(level: AbilityConstant.MemoryLevel): void {
    const prevLevel = this.currentLevel;
    this.currentLevel = level;

    console.warn(`[TensionHandler] 内存压力变化: ${prevLevel} → ${level}`);

    switch (level) {
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_MODERATE:
        this.handleModerate();
        break;
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_LOW:
        this.handleLow();
        break;
      default:
        // CRITICAL或未知级别，按最严重处理
        this.handleCritical();
        break;
    }

    // 记录处理后的内存状态
    this.logMemoryStatus();
  }

  // 适度紧张处理
  private handleModerate(): void {
    console.info('[TensionHandler] 🟡 适度紧张：轻度优化');

    // 1. 缩减缓存容量至50%
    AppStorage.setOrCreate('cache_capacity_factor', 0.5);

    // 2. 释放标记为"可延迟释放"的资源
    this.releaseResourcesByPriority('low');

    // 3. 减少预加载数量
    AppStorage.setOrCreate('preload_count', 3);  // 从10减至3
  }

  // 严重紧张处理
  private handleLow(): void {
    console.info('[TensionHandler] 🟠 严重紧张：中度优化');

    // 1. 清空非关键缓存
    AppStorage.setOrCreate('memory_action', 'clear_non_essential_cache');

    // 2. 降低图片质量
    AppStorage.setOrCreate('image_quality', 'medium');

    // 3. 释放标记为"可释放"的资源
    this.releaseResourcesByPriority('medium');

    // 4. 停止后台任务
    AppStorage.setOrCreate('background_tasks_enabled', false);

    // 5. 压缩内存中的数据
    AppStorage.setOrCreate('data_compression_enabled', true);
  }

  // 极度紧张处理
  private handleCritical(): void {
    console.info('[TensionHandler] 🔴 极度紧张：重度优化');

    // 1. 清空所有缓存
    AppStorage.setOrCreate('memory_action', 'clear_all_cache');

    // 2. 最低图片质量
    AppStorage.setOrCreate('image_quality', 'low');

    // 3. 释放所有可释放资源
    this.releaseResourcesByPriority('high');

    // 4. 关闭动画效果
    AppStorage.setOrCreate('animations_enabled', false);

    // 5. 进入极简模式
    AppStorage.setOrCreate('app_mode', 'minimal');

    // 6. 释放所有可选资源
    this.releaseAllOptional();
  }

  // 按优先级释放资源
  private releaseResourcesByPriority(maxPriority: string): void {
    const priorityOrder = { 'low': 0, 'medium': 1, 'high': 2 };
    const maxOrder = priorityOrder[maxPriority] ?? 0;

    this.resourceRegistry.forEach((releaseFn, name) => {
      // 简化：根据资源名称中的优先级标记决定是否释放
      const priority = name.includes('critical') ? 2 : name.includes('important') ? 1 : 0;
      if (priority <= maxOrder) {
        const released = releaseFn();
        this.totalReleased += released;
        console.info(`[TensionHandler] 释放资源: ${name}, 回收${released}KB`);
      }
    });
  }

  // 释放所有可选资源
  private releaseAllOptional(): void {
    this.resourceRegistry.forEach((releaseFn, name) => {
      if (!name.includes('essential')) {  // 非核心资源全部释放
        const released = releaseFn();
        this.totalReleased += released;
        console.info(`[TensionHandler] 释放可选资源: ${name}, 回收${released}KB`);
      }
    });
  }

  // 记录内存状态
  private logMemoryStatus(): void {
    try {
      const procMemInfo = hidebug.getProcessMemInfo();
      console.info(`[TensionHandler] 处理后PSS: ${procMemInfo.pss}KB, ` +
        `累计释放: ${this.totalReleased}KB`);
    } catch (err) {
      console.warn('[TensionHandler] 内存状态获取失败');
    }
  }

  // 获取当前状态
  getStatus(): { currentLevel: number; totalReleasedKB: number; registeredResources: number } {
    return {
      currentLevel: this.currentLevel,
      totalReleasedKB: this.totalReleased,
      registeredResources: this.resourceRegistry.size
    };
  }
}

3.2 进阶：内存压缩策略

当释放资源还不够时，压缩内存中的数据是另一条出路。通过压缩不常用的数据，可以在不丢失信息的前提下大幅降低内存占用。

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

// 数据压缩策略
enum CompressionStrategy {
  NONE = 'none',           // 不压缩
  LIGHT = 'light',         // 轻度压缩（快速，压缩率低）
  MEDIUM = 'medium',       // 中度压缩（平衡）
  HEAVY = 'heavy'          // 重度压缩（慢速，压缩率高）
}

// 压缩配置
interface CompressionConfig {
  strategy: CompressionStrategy;
  minSizeToCompress: number;  // 最小压缩阈值（字节），小于此值不压缩
  maxCompressedRatio: number; // 最大压缩比，超过此值说明压缩无效应放弃
}

// 内存数据压缩管理器
class MemoryCompressionManager {
  private config: CompressionConfig;
  private compressedData: Map<string, {
    original: ArrayBuffer;
    compressed: ArrayBuffer;
    ratio: number;
    timestamp: number;
  }> = new Map();
  private totalSaved: number = 0;  // 压缩节省的总字节数

  constructor(config?: Partial<CompressionConfig>) {
    this.config = {
      strategy: CompressionStrategy.MEDIUM,
      minSizeToCompress: 1024,   // 小于1KB不压缩
      maxCompressedRatio: 0.9,   // 压缩后>90%说明无效
      ...config
    };
  }

  // 压缩数据
  compress(key: string, data: ArrayBuffer): ArrayBuffer {
    // 小数据不压缩
    if (data.byteLength < this.config.minSizeToCompress) {
      console.info(`[Compressor] ${key}: 数据太小(${data.byteLength}B)，跳过压缩`);
      return data;
    }

    try {
      // 使用zlib压缩
      const compressed = this.zlibCompress(data);
      const ratio = compressed.byteLength / data.byteLength;

      // 压缩比过高说明数据不适合压缩
      if (ratio > this.config.maxCompressedRatio) {
        console.info(`[Compressor] ${key}: 压缩比${(ratio * 100).toFixed(1)}%过高，放弃压缩`);
        return data;
      }

      // 保存压缩信息
      const saved = data.byteLength - compressed.byteLength;
      this.totalSaved += saved;
      this.compressedData.set(key, {
        original: data,
        compressed,
        ratio,
        timestamp: Date.now()
      });

      console.info(`[Compressor] ${key}: ${data.byteLength}B → ${compressed.byteLength}B ` +
        `(节省${(saved / 1024).toFixed(1)}KB, 压缩比${(ratio * 100).toFixed(1)}%)`);
      return compressed;
    } catch (err) {
      console.warn(`[Compressor] ${key}: 压缩失败，返回原始数据`);
      return data;
    }
  }

  // 解压数据
  decompress(key: string): ArrayBuffer | undefined {
    const entry = this.compressedData.get(key);
    if (!entry) {
      return undefined;
    }

    try {
      const decompressed = this.zlibDecompress(entry.compressed);
      console.info(`[Compressor] ${key}: 解压完成 ${entry.compressed.byteLength}B → ${decompressed.byteLength}B`);
      return decompressed;
    } catch (err) {
      console.error(`[Compressor] ${key}: 解压失败，尝试返回原始数据`);
      return entry.original;
    }
  }

  // zlib压缩实现
  private zlibCompress(data: ArrayBuffer): ArrayBuffer {
    try {
      // 使用util模块的压缩功能
      const inputData = buffer.from(data);
      const compressed = util.zlib.compressSync(inputData);
      return compressed.buffer;
    } catch (err) {
      // 降级：简单的RLE压缩
      return this.rleCompress(data);
    }
  }

  // zlib解压实现
  private zlibDecompress(data: ArrayBuffer): ArrayBuffer {
    try {
      const inputData = buffer.from(data);
      const decompressed = util.zlib.decompressSync(inputData);
      return decompressed.buffer;
    } catch (err) {
      // 降级：RLE解压
      return this.rleDecompress(data);
    }
  }

  // 简单RLE压缩（降级方案）
  private rleCompress(data: ArrayBuffer): ArrayBuffer {
    const input = new Uint8Array(data);
    const output: number[] = [];
    let i = 0;

    while (i < input.length) {
      let count = 1;
      while (i + count < input.length && input[i + count] === input[i] && count < 255) {
        count++;
      }
      output.push(count, input[i]);
      i += count;
    }

    const result = new ArrayBuffer(output.length);
    const view = new Uint8Array(result);
    for (let j = 0; j < output.length; j++) {
      view[j] = output[j];
    }
    return result;
  }

  // 简单RLE解压（降级方案）
  private rleDecompress(data: ArrayBuffer): ArrayBuffer {
    const input = new Uint8Array(data);
    const output: number[] = [];

    for (let i = 0; i < input.length; i += 2) {
      const count = input[i];
      const value = input[i + 1];
      for (let j = 0; j < count; j++) {
        output.push(value);
      }
    }

    const result = new ArrayBuffer(output.length);
    const view = new Uint8Array(result);
    for (let j = 0; j < output.length; j++) {
      view[j] = output[j];
    }
    return result;
  }

  // 根据内存压力级别调整压缩策略
  adaptToMemoryLevel(level: number): void {
    switch (level) {
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_MODERATE:
        this.config.strategy = CompressionStrategy.LIGHT;
        this.config.minSizeToCompress = 2048;  // 放宽压缩阈值
        break;
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_LOW:
        this.config.strategy = CompressionStrategy.MEDIUM;
        this.config.minSizeToCompress = 512;   // 收紧压缩阈值
        break;
      default:
        this.config.strategy = CompressionStrategy.HEAVY;
        this.config.minSizeToCompress = 256;   // 最小阈值
        break;
    }
    console.info(`[Compressor] 压缩策略调整为: ${this.config.strategy}`);
  }

  // 获取压缩统计
  getStats(): { compressedCount: number; totalSavedKB: number; avgRatio: string } {
    let totalRatio = 0;
    this.compressedData.forEach(entry => {
      totalRatio += entry.ratio;
    });
    const avgRatio = this.compressedData.size > 0
      ? ((totalRatio / this.compressedData.size) * 100).toFixed(1) + '%'
      : 'N/A';

    return {
      compressedCount: this.compressedData.size,
      totalSavedKB: parseFloat((this.totalSaved / 1024).toFixed(1)),
      avgRatio
    };
  }

  // 释放所有压缩数据
  releaseAll(): void {
    this.compressedData.clear();
    this.totalSaved = 0;
    console.info('[Compressor] 已释放所有压缩数据');
  }
}

3.3 进阶：资源按需释放

资源按需释放的核心思想是"用的时候加载，不用的时候释放"，通过资源优先级和生命周期管理，确保在内存紧张时能精准释放最不重要的资源。

// 资源优先级
enum ResourcePriority {
  CRITICAL = 0,     // 关键资源：不可释放（如当前页面数据）
  HIGH = 1,         // 高优先级：仅在极度紧张时释放
  MEDIUM = 2,       // 中优先级：严重紧张时释放
  LOW = 3           // 低优先级：适度紧张时即可释放
}

// 资源描述
interface ResourceDescriptor {
  name: string;                    // 资源名称
  priority: ResourcePriority;      // 优先级
  estimatedSize: number;           // 预估大小（KB）
  lastAccessTime: number;          // 最后访问时间
  releaseCallback: () => boolean;  // 释放回调，返回是否成功
  reloadCallback: () => boolean;   // 重载回调
}

// 资源管理器
class ResourceManager {
  private resources: Map<string, ResourceDescriptor> = new Map();
  private releasedResources: Set<string> = new Set();  // 已释放的资源名称

  // 注册资源
  register(descriptor: ResourceDescriptor): void {
    this.resources.set(descriptor.name, descriptor);
    console.info(`[ResourceMgr] 注册资源: ${descriptor.name}, ` +
      `优先级=${descriptor.priority}, 大小=${descriptor.estimatedSize}KB`);
  }

  // 注销资源
  unregister(name: string): void {
    this.resources.delete(name);
    this.releasedResources.delete(name);
  }

  // 按内存压力级别释放资源
  releaseByMemoryLevel(level: number): { released: string[]; freedKB: number } {
    // 确定可释放的最低优先级
    let minPriority: ResourcePriority;
    switch (level) {
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_MODERATE:
        minPriority = ResourcePriority.LOW;       // 只释放低优先级
        break;
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_LOW:
        minPriority = ResourcePriority.MEDIUM;    // 释放中+低优先级
        break;
      default:
        minPriority = ResourcePriority.HIGH;      // 释放高+中+低优先级
        break;
    }

    const released: string[] = [];
    let freedKB = 0;

    // 按优先级从低到高、访问时间从旧到新排序
    const sortedResources = Array.from(this.resources.values())
      .filter(r => r.priority >= minPriority && !this.releasedResources.has(r.name))
      .sort((a, b) => {
        // 先按优先级排序（低优先级先释放）
        if (a.priority !== b.priority) return b.priority - a.priority;
        // 同优先级按访问时间排序（旧的先释放）
        return a.lastAccessTime - b.lastAccessTime;
      });

    for (const resource of sortedResources) {
      const success = resource.releaseCallback();
      if (success) {
        released.push(resource.name);
        freedKB += resource.estimatedSize;
        this.releasedResources.add(resource.name);
        console.info(`[ResourceMgr] 释放资源: ${resource.name}, ` +
          `优先级=${resource.priority}, 回收${resource.estimatedSize}KB`);
      }
    }

    console.info(`[ResourceMgr] 本轮释放: ${released.length}个资源, 共${freedKB}KB`);
    return { released, freedKB };
  }

  // 重新加载已释放的资源
  reloadResource(name: string): boolean {
    const resource = this.resources.get(name);
    if (!resource || !this.releasedResources.has(name)) {
      return false;
    }

    const success = resource.reloadCallback();
    if (success) {
      this.releasedResources.delete(name);
      resource.lastAccessTime = Date.now();
      console.info(`[ResourceMgr] 重载资源: ${name}`);
    }
    return success;
  }

  // 更新资源访问时间
  touch(name: string): void {
    const resource = this.resources.get(name);
    if (resource) {
      resource.lastAccessTime = Date.now();
    }
  }

  // 获取资源统计
  getStats(): {
    totalResources: number;
    releasedCount: number;
    totalEstimatedKB: number;
    releasedEstimatedKB: number;
  } {
    let totalKB = 0;
    let releasedKB = 0;

    this.resources.forEach((r, name) => {
      totalKB += r.estimatedSize;
      if (this.releasedResources.has(name)) {
        releasedKB += r.estimatedSize;
      }
    });

    return {
      totalResources: this.resources.size,
      releasedCount: this.releasedResources.size,
      totalEstimatedKB: totalKB,
      releasedEstimatedKB: releasedKB
    };
  }
}

3.4 完整：低内存设备适配与内存紧张处理实战

将上述所有模块整合，实现完整的内存紧张处理系统。

import { UIAbility, AbilityConstant } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';
import { deviceInfo } from '@kit.BasicServicesKit';

// 设备内存等级
enum DeviceMemoryTier {
  VERY_LOW = 'very_low',   // <1.5GB
  LOW = 'low',             // 1.5-3GB
  MEDIUM = 'medium',       // 3-6GB
  HIGH = 'high'            // >6GB
}

// 应用配置（根据设备内存等级动态调整）
interface AdaptiveConfig {
  imageQuality: 'low' | 'medium' | 'high';
  cacheCapacityFactor: number;    // 缓存容量系数（0-1）
  preloadCount: number;           // 预加载数量
  animationsEnabled: boolean;     // 是否启用动画
  compressionEnabled: boolean;    // 是否启用数据压缩
  backgroundTasksEnabled: boolean; // 是否启用后台任务
}

// 内存紧张处理总控
class MemoryTensionController {
  private tensionHandler: MemoryTensionHandler;
  private compressionManager: MemoryCompressionManager;
  private resourceManager: ResourceManager;
  private deviceTier: DeviceMemoryTier;
  private adaptiveConfig: AdaptiveConfig;
  private onConfigChange?: (config: AdaptiveConfig) => void;

  constructor() {
    this.tensionHandler = new MemoryTensionHandler();
    this.compressionManager = new MemoryCompressionManager();
    this.resourceManager = new ResourceManager();

    // 检测设备内存等级
    this.deviceTier = this.detectDeviceTier();
    // 根据设备等级初始化配置
    this.adaptiveConfig = this.getAdaptiveConfig(this.deviceTier);

    console.info(`[TensionCtrl] 设备等级: ${this.deviceTier}, ` +
      `图片质量: ${this.adaptiveConfig.imageQuality}, ` +
      `缓存系数: ${this.adaptiveConfig.cacheCapacityFactor}`);
  }

  // 检测设备内存等级
  private detectDeviceTier(): DeviceMemoryTier {
    try {
      const totalMemKB = deviceInfo.totalMemory ?? 2048 * 1024;
      const totalMemGB = totalMemKB / (1024 * 1024);

      if (totalMemGB < 1.5) return DeviceMemoryTier.VERY_LOW;
      if (totalMemGB < 3) return DeviceMemoryTier.LOW;
      if (totalMemGB < 6) return DeviceMemoryTier.MEDIUM;
      return DeviceMemoryTier.HIGH;
    } catch (err) {
      console.warn('[TensionCtrl] 设备信息获取失败，默认LOW');
      return DeviceMemoryTier.LOW;
    }
  }

  // 根据设备等级获取自适应配置
  private getAdaptiveConfig(tier: DeviceMemoryTier): AdaptiveConfig {
    switch (tier) {
      case DeviceMemoryTier.VERY_LOW:
        return {
          imageQuality: 'low',
          cacheCapacityFactor: 0.3,
          preloadCount: 1,
          animationsEnabled: false,
          compressionEnabled: true,
          backgroundTasksEnabled: false
        };
      case DeviceMemoryTier.LOW:
        return {
          imageQuality: 'medium',
          cacheCapacityFactor: 0.5,
          preloadCount: 3,
          animationsEnabled: true,
          compressionEnabled: true,
          backgroundTasksEnabled: false
        };
      case DeviceMemoryTier.MEDIUM:
        return {
          imageQuality: 'high',
          cacheCapacityFactor: 0.75,
          preloadCount: 5,
          animationsEnabled: true,
          compressionEnabled: false,
          backgroundTasksEnabled: true
        };
      case DeviceMemoryTier.HIGH:
        return {
          imageQuality: 'high',
          cacheCapacityFactor: 1.0,
          preloadCount: 10,
          animationsEnabled: true,
          compressionEnabled: false,
          backgroundTasksEnabled: true
        };
    }
  }

  // 处理内存压力回调（总入口）
  handleMemoryLevel(level: AbilityConstant.MemoryLevel): void {
    // 1. 通知紧张处理器
    this.tensionHandler.handleMemoryLevel(level);

    // 2. 调整压缩策略
    this.compressionManager.adaptToMemoryLevel(level);

    // 3. 释放资源
    const { released, freedKB } = this.resourceManager.releaseByMemoryLevel(level);
    console.info(`[TensionCtrl] 资源释放: ${released.length}个, ${freedKB}KB`);

    // 4. 更新自适应配置
    this.updateAdaptiveConfig(level);

    // 5. 通知UI层
    this.onConfigChange?.(this.adaptiveConfig);
  }

  // 根据内存压力更新配置
  private updateAdaptiveConfig(level: number): void {
    switch (level) {
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_MODERATE:
        this.adaptiveConfig.cacheCapacityFactor = Math.min(
          this.adaptiveConfig.cacheCapacityFactor, 0.5
        );
        this.adaptiveConfig.preloadCount = Math.min(
          this.adaptiveConfig.preloadCount, 3
        );
        break;
      case AbilityConstant.MemoryLevel.MEMORY_LEVEL_LOW:
        this.adaptiveConfig.imageQuality = 'low';
        this.adaptiveConfig.cacheCapacityFactor = 0.2;
        this.adaptiveConfig.preloadCount = 1;
        this.adaptiveConfig.backgroundTasksEnabled = false;
        break;
      default:
        this.adaptiveConfig.imageQuality = 'low';
        this.adaptiveConfig.cacheCapacityFactor = 0.1;
        this.adaptiveConfig.animationsEnabled = false;
        this.adaptiveConfig.compressionEnabled = true;
        break;
    }
  }

  // 注册资源
  registerResource(descriptor: ResourceDescriptor): void {
    this.resourceManager.register(descriptor);
  }

  // 设置配置变更回调
  setOnConfigChange(callback: (config: AdaptiveConfig) => void): void {
    this.onConfigChange = callback;
  }

  // 获取当前配置
  getConfig(): AdaptiveConfig {
    return { ...this.adaptiveConfig };
  }

  // 获取综合状态
  getStatus(): object {
    return {
      deviceTier: this.deviceTier,
      config: this.adaptiveConfig,
      tension: this.tensionHandler.getStatus(),
      compression: this.compressionManager.getStats(),
      resources: this.resourceManager.getStats()
    };
  }
}

// UI层：自适应配置消费
@Entry
@Component
struct MemoryTensionDemoPage {
  @State configText: string = '初始化中...';
  @State statusText: string = '';
  private controller: MemoryTensionController = new MemoryTensionController();

  aboutToAppear(): void {
    // 设置配置变更回调
    this.controller.setOnConfigChange((config) => {
      this.updateDisplay();
      console.info(`[Demo] 配置已更新: 图片=${config.imageQuality}, ` +
        `缓存=${config.cacheCapacityFactor}, 动画=${config.animationsEnabled}`);
    });

    this.updateDisplay();
  }

  updateDisplay(): void {
    const config = this.controller.getConfig();
    const status = this.controller.getStatus();

    this.configText = [
      `📱 当前自适应配置:`,
      `  图片质量: ${config.imageQuality}`,
      `  缓存系数: ${config.cacheCapacityFactor}`,
      `  预加载数: ${config.preloadCount}`,
      `  动画: ${config.animationsEnabled ? '✅' : '❌'}`,
      `  压缩: ${config.compressionEnabled ? '✅' : '❌'}`,
      `  后台任务: ${config.backgroundTasksEnabled ? '✅' : '❌'}`
    ].join('\n');

    this.statusText = JSON.stringify(status, null, 2);
  }

  build() {
    Scroll() {
      Column({ space: 16 }) {
        Text('🧠 内存紧张处理演示')
          .fontSize(22)
          .fontWeight(FontWeight.Bold)

        Text(this.configText)
          .fontSize(13)
          .fontFamily('monospace')
          .padding(12)
          .backgroundColor('#E3F2FD')
          .borderRadius(8)
          .width('100%')

        Row({ space: 12 }) {
          Button('模拟MODERATE')
            .onClick(() => {
              this.controller.handleMemoryLevel(
                AbilityConstant.MemoryLevel.MEMORY_LEVEL_MODERATE
              );
              this.updateDisplay();
            })
            .backgroundColor('#FF9800')

          Button('模拟LOW')
            .onClick(() => {
              this.controller.handleMemoryLevel(
                AbilityConstant.MemoryLevel.MEMORY_LEVEL_LOW
              );
              this.updateDisplay();
            })
            .backgroundColor('#F44336')

          Button('模拟CRITICAL')
            .onClick(() => {
              this.controller.handleMemoryLevel(2);  // CRITICAL
              this.updateDisplay();
            })
            .backgroundColor('#B71C1C')
            .fontColor('#FFFFFF')
        }

        Button('恢复正常')
          .onClick(() => {
            this.controller = new MemoryTensionController();
            this.updateDisplay();
          })
          .backgroundColor('#4CAF50')
          .width('60%')
      }
      .width('100%')
      .padding(16)
    }
  }
}

四、踩坑与注意事项

坑点1：压缩/解压的CPU开销

数据压缩确实能节省内存，但压缩和解压都需要CPU计算。在内存紧张时，CPU可能也在高负载运行（因为GC更频繁了），此时再进行压缩可能雪上加霜。建议：

• 仅对大于1KB的数据进行压缩
• 使用轻度压缩（压缩率低但速度快）而非重度压缩
• 在空闲时段预压缩，而非在内存紧张时才压缩

坑点2：资源释放后用户立即访问

刚释放了一个"不常用"的资源，用户偏偏马上就要用——这种情况比你想象的更常见。解决方案：

1. 懒加载：释放时保留重载回调，访问时自动重载
2. 占位符：释放后显示占位内容（如低分辨率缩略图），而非空白
3. 预判：根据用户行为预测下一步可能需要的资源，提前重载

坑点3：onMemoryLevel回调在后台时不触发

当应用在后台时，系统可能不会触发onMemoryLevel回调，而是直接杀掉进程。因此，在应用进入后台时就应该主动释放资源，不要等系统通知。

// 应用进入后台时主动释放
onBackground(): void {
  console.info('[App] 进入后台，主动释放资源');
  this.resourceManager.releaseByMemoryLevel(
    AbilityConstant.MemoryLevel.MEMORY_LEVEL_MODERATE
  );
}

坑点4：低内存设备上动画关闭的体验问题

关闭动画确实能节省内存和CPU，但也会让应用显得"生硬"。建议用更轻量的过渡效果替代完全关闭：

// ❌ 完全关闭动画
AppStorage.setOrCreate('animations_enabled', false);

// ✅ 用轻量过渡替代
AppStorage.setOrCreate('animation_duration', 100);  // 缩短动画时长至100ms
AppStorage.setOrCreate('animation_type', 'fade');    // 用淡入淡出替代复杂动画

坑点5：设备内存检测的准确性

deviceInfo.totalMemory在某些设备上可能返回不准确的值，或者返回的是物理内存而非可用内存。建议结合实际运行时的内存信息进行判断，而非完全依赖设备信息。

坑点6：压缩数据的生命周期管理

压缩数据需要同时保存原始数据和解压后的数据，否则解压时找不到原始数据。但保存两份数据反而增加了内存占用。解决方案：

• 只保存压缩后的数据，需要时再解压
• 设置压缩数据的TTL，长时间未访问的压缩数据直接丢弃
• 压缩后立即释放原始数据的引用

坑点7：多Ability场景下的资源竞争

在分屏模式下，两个Ability共享应用的内存配额。如果一个Ability大量占用内存，另一个Ability可能被迫释放资源。需要在应用级别统一管理资源，而非每个Ability各自为战。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. CRITICAL级别行为：HarmonyOS 6在CRITICAL级别时，系统会限制应用的CPU时间片，应用需尽快完成资源释放
2. 压缩算法优化：新增LZ4压缩支持，压缩速度比zlib快5-10倍，适合实时压缩场景
3. 后台内存限制：后台应用的内存配额被进一步压缩，建议后台时主动释放50%以上的内存

适配代码

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

// HarmonyOS 6 LZ4快速压缩适配
class FastCompressionAdapter {
  // 快速压缩（优先使用LZ4）
  async compressFast(data: ArrayBuffer): Promise<ArrayBuffer> {
    try {
      // HarmonyOS 6 新增LZ4压缩
      const inputData = buffer.from(data);
      const compressed = util.lz4.compressSync(inputData);
      console.info(`[FastCompress] LZ4压缩: ${data.byteLength}B → ${compressed.length}B`);
      return compressed.buffer;
    } catch (err) {
      // 降级到zlib
      console.warn('[FastCompress] LZ4不可用，降级到zlib');
      return this.zlibCompress(data);
    }
  }

  // 快速解压
  async decompressFast(data: ArrayBuffer, originalSize: number): Promise<ArrayBuffer> {
    try {
      const inputData = buffer.from(data);
      const decompressed = util.lz4.decompressSync(inputData, originalSize);
      return decompressed.buffer;
    } catch (err) {
      console.warn('[FastCompress] LZ4解压失败，尝试zlib');
      return this.zlibDecompress(data);
    }
  }

  private zlibCompress(data: ArrayBuffer): ArrayBuffer {
    const inputData = buffer.from(data);
    const compressed = util.zlib.compressSync(inputData);
    return compressed.buffer;
  }

  private zlibDecompress(data: ArrayBuffer): ArrayBuffer {
    const inputData = buffer.from(data);
    const decompressed = util.zlib.decompressSync(inputData);
    return decompressed.buffer;
  }
}

// HarmonyOS 6 内存建议API适配
function getMemoryAdvice(): string {
  try {
    // HarmonyOS 6 新增API
    const advice = hidebug.getMemoryAdvice();
    switch (advice.level) {
      case 'normal':
        return '✅ 内存正常，可以正常使用';
      case 'moderate':
        return '⚠️ 建议释放部分缓存';
      case 'low':
        return '🟠 建议释放非必要资源';
      case 'critical':
        return '🔴 建议立即释放所有可释放资源';
      default:
        return '未知状态';
    }
  } catch (err) {
    // 降级：使用传统方式判断
    return '内存建议API不可用，请使用水位线监控';
  }
}

六、总结

三维度评价表

内存紧张处理是"带着镣铐跳舞"的艺术——在有限的内存空间内，既要保证核心功能可用，又要尽可能保留用户体验。关键在于三个词：分级、压缩、自适应。

• 分级：不同级别的内存压力采取不同力度的措施，避免过度优化或优化不足
• 压缩：通过数据压缩在信息量和内存占用之间找到平衡点
• 自适应：根据设备能力和运行时状态动态调整策略，让应用像水一样适应容器

最终的目标是：让每个用户，无论使用什么设备，都能获得与其设备能力匹配的最佳体验。在旗舰机上享受高清图片和流畅动画，在入门机上也能正常使用核心功能——这才是真正的"全民适配"。