HarmonyOS APP开发：内存泄漏检测与LeakCanary集成

📌 核心要点：掌握鸿蒙应用内存泄漏的检测方法与修复策略，从WeakRef弱引用检测到自动化泄漏检测框架，彻底告别内存泄漏这个"隐形杀手"。

一、背景与动机

你有没有遇到过这样的场景：应用刚启动时内存只有80MB，用着用着就涨到了200MB，退出页面后内存也不见下降，最终系统一纸"OOM"判决书把你的应用送上了断头台？

这就是内存泄漏的典型表现——对象已经不再被需要，却因为某些隐式引用而无法被垃圾回收器回收。就像你搬了新家，但旧家的钥匙一直没交出去，旧房子就永远占着那块地，谁也用不了。

内存泄漏之所以被称为"隐形杀手"，是因为它不像崩溃那样立刻暴露问题，而是像温水煮青蛙一样，一点一点蚕食可用内存，直到某一天突然爆发。更可怕的是，内存泄漏往往在开发阶段难以察觉——开发机的内存通常很充裕，问题只在低端设备或长时间使用后才会显现。

在鸿蒙应用开发中，内存泄漏的场景更加多样：ArkTS的闭包捕获、组件生命周期管理、Native资源释放、事件监听器注册……每一个环节都可能成为泄漏的入口。本文将从内存泄漏的原理出发，带你逐一排查常见泄漏场景，并构建一套自动化泄漏检测框架，让你的应用真正做到"内存无忧"。

二、核心原理

2.1 内存泄漏的本质

内存泄漏的本质是可达性分析失败——对象已经不再被业务逻辑需要，但从GC Roots出发仍然可以到达该对象，导致GC无法回收它。

flowchart TD
    subgraph GCRoots["🌳 GC Roots"]
        R1[栈帧局部变量]
        R2[全局对象]
        R3[活跃的定时器]
        R4[Native引用]
    end

    subgraph 正常引用["✅ 正常引用链"]
        R1 --> A[页面组件]
        A --> B[数据模型]
        B --> C[列表项]
    end

    subgraph 泄漏引用["🔴 泄漏引用链"]
        R3 --> D[已销毁的组件]
        D --> E[大图片缓存]
        R2 --> F[全局监听器]
        F --> G[已关闭的页面]
        G --> H[网络响应数据]
    end

    classDef rootStyle fill:#2ECC71,stroke:#27AE60,color:#fff,stroke-width:2px
    classDef normalStyle fill:#3498DB,stroke:#2980B9,color:#fff,stroke-width:2px
    classDef leakStyle fill:#E74C3C,stroke:#C0392B,color:#fff,stroke-width:2px

    class R1,R2,R3,R4 rootStyle
    class A,B,C normalStyle
    class D,E,F,G,H leakStyle

2.2 内存泄漏分类

2.3 WeakRef弱引用检测原理

ArkTS提供了WeakRefAPI，它允许你持有对一个对象的弱引用——弱引用不会阻止GC回收该对象。利用这个特性，我们可以检测对象是否被正确回收：

flowchart LR
    A[创建目标对象] --> B[用WeakRef包装]
    B --> C[业务代码正常使用]
    C --> D[预期回收时机后]
    D --> E{weakRef.deref是否为undefined?}
    E -->|是| F[✅ 对象已正确回收]
    E -->|否| G[🔴 疑似内存泄漏]
    G --> H[追踪引用链]

    classDef normalStyle fill:#2ECC71,stroke:#27AE60,color:#fff,stroke-width:2px
    classDef leakStyle fill:#E74C3C,stroke:#C0392B,color:#fff,stroke-width:2px
    classDef processStyle fill:#3498DB,stroke:#2980B9,color:#fff,stroke-width:2px

    class A,B,C,D processStyle
    class F normalStyle
    class G,H leakStyle

核心思路：在对象应该被回收的时间点之后，检查WeakRef.deref()是否返回undefined。如果对象仍然存在，说明存在强引用链阻止了GC回收，即存在内存泄漏。

三、代码实战

3.1 基础示例：WeakRef泄漏检测工具

下面实现一个基于WeakRef的轻量级泄漏检测工具，可以追踪任意对象是否被正确回收：

// WeakRef泄漏检测工具 - 追踪对象是否被正确回收
class LeakDetector {
  // 存储所有被追踪对象的弱引用
  private trackedObjects: Map<string, WeakRef<object>> = new Map()
  // 对象描述信息，用于生成报告
  private objectDescriptions: Map<string, string> = new Map()
  // 检测结果记录
  private detectionResults: Map<string, 'leaked' | 'collected' | 'pending'> = new Map()

  // 追踪一个对象 - 注册到检测列表
  track(obj: object, tag: string, description: string = ''): void {
    const weakRef = new WeakRef(obj)
    this.trackedObjects.set(tag, weakRef)
    this.objectDescriptions.set(tag, description || `Object[${tag}]`)
    this.detectionResults.set(tag, 'pending')
    console.info(`[LeakDetector] 开始追踪: ${tag} - ${description}`)
  }

  // 检查所有追踪对象的状态
  checkAll(): { leaked: string[]; collected: string[]; pending: string[] } {
    const leaked: string[] = []
    const collected: string[] = []
    const pending: string[] = []

    this.trackedObjects.forEach((weakRef, tag) => {
      const obj = weakRef.deref()
      if (obj === undefined) {
        // 对象已被GC回收
        if (this.detectionResults.get(tag) !== 'collected') {
          this.detectionResults.set(tag, 'collected')
          console.info(`[LeakDetector] ✅ 已回收: ${tag}`)
        }
        collected.push(tag)
      } else {
        // 对象仍然存在
        leaked.push(tag)
        if (this.detectionResults.get(tag) !== 'leaked') {
          this.detectionResults.set(tag, 'leaked')
          console.warn(`[LeakDetector] 🔴 疑似泄漏: ${tag}`)
        }
      }
    })

    return { leaked, collected, pending }
  }

  // 生成泄漏检测报告
  generateReport(): string {
    const result = this.checkAll()
    let report = '=== 内存泄漏检测报告 ===\n'
    report += `检测时间: ${new Date().toLocaleString()}\n`
    report += `追踪对象总数: ${this.trackedObjects.size}\n`
    report += `✅ 已回收: ${result.collected.length}\n`
    report += `🔴 疑似泄漏: ${result.leaked.length}\n\n`

    if (result.leaked.length > 0) {
      report += '--- 泄漏对象详情 ---\n'
      result.leaked.forEach(tag => {
        const desc = this.objectDescriptions.get(tag) || '未知对象'
        report += `  🔴 ${tag}: ${desc}\n`
      })
    }

    return report
  }

  // 清除已回收对象的追踪记录
  cleanup(): void {
    const toDelete: string[] = []
    this.trackedObjects.forEach((weakRef, tag) => {
      if (weakRef.deref() === undefined) {
        toDelete.push(tag)
      }
    })
    toDelete.forEach(tag => {
      this.trackedObjects.delete(tag)
      this.objectDescriptions.delete(tag)
      this.detectionResults.delete(tag)
    })
  }
}

// 全局泄漏检测器实例
const leakDetector = new LeakDetector()

3.2 进阶示例：常见泄漏场景与修复

下面展示鸿蒙开发中最常见的四种内存泄漏场景，以及对应的修复方案：

// ===== 场景1: 闭包泄漏 =====
// ❌ 错误写法 - 闭包捕获了组件实例
class EventBus {
  private listeners: Map<string, Array<() => void>> = new Map()

  on(event: string, callback: () => void): void {
    const list = this.listeners.get(event) || []
    list.push(callback)
    this.listeners.set(event, list)
  }

  emit(event: string): void {
    const list = this.listeners.get(event)
    if (list) {
      list.forEach(cb => cb())
    }
  }
}

const globalEventBus = new EventBus()

@Component
struct LeakByClosurePage {
  @State count: number = 0

  build() {
    Column() {
      Text(`计数: ${this.count}`)
      Button('增加').onClick(() => this.count++)
    }
    .onAppear(() => {
      // ❌ 闭包捕获了this（组件实例），页面销毁后回调仍持有引用
      globalEventBus.on('update', () => {
        this.count++  // 隐式引用了this
      })
    })
  }
}

// ✅ 正确写法 - 使用弱引用或及时注销
@Component
struct FixedClosurePage {
  @State count: number = 0
  private callbackId: string = ''

  build() {
    Column() {
      Text(`计数: ${this.count}`)
      Button('增加').onClick(() => this.count++)
    }
    .onAppear(() => {
      // 保存回调引用，以便后续注销
      const callback = () => { this.count++ }
      this.callbackId = `update_${Date.now()}`
      globalEventBus.on(this.callbackId, callback)
    })
    .onDisappear(() => {
      // ✅ 页面销毁时注销事件监听
      globalEventBus.off(this.callbackId)
    })
  }
}

// ===== 场景2: 定时器泄漏 =====
@Component
struct TimerLeakPage {
  @State time: string = ''
  private timerId: number = -1

  build() {
    Column() {
      Text(`当前时间: ${this.time}`)
    }
    .onAppear(() => {
      // ❌ 如果不在onDisappear中清理，定时器会一直运行
      this.timerId = setInterval(() => {
        this.time = new Date().toLocaleTimeString()
      }, 1000) as number
    })
    .onDisappear(() => {
      // ✅ 清理定时器
      if (this.timerId !== -1) {
        clearInterval(this.timerId)
        this.timerId = -1
      }
    })
  }
}

// ===== 场景3: 组件引用泄漏 =====
// ❌ 错误写法 - 全局管理器持有组件强引用
class ComponentManager {
  private components: Map<string, object> = new Map()  // 强引用！

  register(name: string, component: object): void {
    this.components.set(name, component)
  }

  unregister(name: string): void {
    this.components.delete(name)
  }
}

const globalComponentManager = new ComponentManager()

// ✅ 正确写法 - 使用WeakRef避免强引用
class SafeComponentManager {
  private weakComponents: Map<string, WeakRef<object>> = new Map()

  register(name: string, component: object): void {
    this.weakComponents.set(name, new WeakRef(component))
  }

  get(name: string): object | undefined {
    const weakRef = this.weakComponents.get(name)
    return weakRef?.deref()
  }

  // 清理已被GC回收的弱引用
  cleanup(): void {
    const toDelete: string[] = []
    this.weakComponents.forEach((weakRef, name) => {
      if (weakRef.deref() === undefined) {
        toDelete.push(name)
      }
    })
    toDelete.forEach(name => this.weakComponents.delete(name))
  }
}

// ===== 场景4: Native资源泄漏 =====
@Component
struct NativeResourcePage {
  private pixelMap: image.PixelMap | null = null

  build() {
    Column() {
      if (this.pixelMap) {
        Image(this.pixelMap)
          .width(200)
          .height(200)
      }
    }
    .onAppear(() => {
      this.loadImage()
    })
    .onDisappear(() => {
      // ✅ 必须手动释放Native资源
      this.releaseNativeResources()
    })
  }

  // 加载图片
  private async loadImage() {
    try {
      const context = getContext(this)
      const rawFile = await context.resourceManager.getRawFileContent('large_image.png')
      const imageSource = image.createImageSource(rawFile.buffer)
      this.pixelMap = await imageSource.createPixelMap()
    } catch (e) {
      console.error('[NativeResource] 图片加载失败', e)
    }
  }

  // 释放Native资源
  private releaseNativeResources() {
    if (this.pixelMap) {
      this.pixelMap.release()  // ✅ 显式释放PixelMap
      this.pixelMap = null
    }
  }
}

3.3 完整示例：自动化内存泄漏检测框架

下面实现一个完整的自动化泄漏检测框架，灵感来源于Android平台的LeakCanary，但针对鸿蒙ArkTS环境进行了重新设计：

import { LeakDetector } from './LeakDetector'

// 泄漏检测配置
interface LeakDetectConfig {
  enabled: boolean              // 是否启用检测
  checkIntervalMs: number       // 检测间隔（毫秒）
  watchDelayMs: number          // 对象回收等待时间
  maxTrackedObjects: number     // 最大追踪对象数
  onLeakDetected?: (info: LeakInfo) => void  // 泄漏回调
}

// 泄漏信息
interface LeakInfo {
  tag: string                   // 对象标签
  description: string           // 对象描述
  createdAt: number             // 创建时间
  detectedAt: number            // 检测到泄漏的时间
  objectSize?: number           // 对象预估大小
  stackTrace?: string           // 创建时的调用栈
}

// 自动化泄漏检测框架
class HarmonyLeakCanary {
  private static instance: HarmonyLeakCanary | null = null
  private detector: LeakDetector = new LeakDetector()
  private config: LeakDetectConfig = {
    enabled: true,
    checkIntervalMs: 5000,
    watchDelayMs: 3000,
    maxTrackedObjects: 100,
  }
  private leakHistory: LeakInfo[] = []
  private checkTimerId: number = -1
  private pendingChecks: Map<string, { weakRef: WeakRef<object>; createdAt: number; description: string; stackTrace: string }> = new Map()

  // 获取单例
  static getInstance(): HarmonyLeakCanary {
    if (!HarmonyLeakCanary.instance) {
      HarmonyLeakCanary.instance = new HarmonyLeakCanary()
    }
    return HarmonyLeakCanary.instance
  }

  // 初始化配置
  init(config: Partial<LeakDetectConfig>): void {
    this.config = { ...this.config, ...config }
    if (this.config.enabled) {
      this.startPeriodicCheck()
    }
  }

  // 监控一个对象 - 在对象应该被回收前调用
  watch(obj: object, tag: string, description: string = ''): void {
    if (!this.config.enabled) return
    if (this.pendingChecks.size >= this.config.maxTrackedObjects) {
      console.warn('[LeakCanary] 追踪对象数已达上限，跳过: ' + tag)
      return
    }

    const weakRef = new WeakRef(obj)
    const stackTrace = this.captureStackTrace()
    const createdAt = Date.now()

    this.pendingChecks.set(tag, {
      weakRef,
      createdAt,
      description: description || `Object[${tag}]`,
      stackTrace
    })

    // 同时注册到基础检测器
    this.detector.track(obj, tag, description)

    console.info(`[LeakCanary] 开始监控: ${tag} - ${description}`)
  }

  // 监控组件 - 在组件onDisappear后自动检测
  watchComponent(componentName: string, componentRef: object): void {
    this.watch(componentRef, `Component:${componentName}`, `组件实例 - ${componentName}`)
  }

  // 启动周期性检测
  private startPeriodicCheck(): void {
    if (this.checkTimerId !== -1) return

    this.checkTimerId = setInterval(() => {
      this.performCheck()
    }, this.config.checkIntervalMs) as number
  }

  // 停止周期性检测
  stopPeriodicCheck(): void {
    if (this.checkTimerId !== -1) {
      clearInterval(this.checkTimerId)
      this.checkTimerId = -1
    }
  }

  // 执行一次检测
  private performCheck(): void {
    const now = Date.now()
    const toRemove: string[] = []

    this.pendingChecks.forEach((info, tag) => {
      // 等待足够时间让GC有机会回收
      if (now - info.createdAt < this.config.watchDelayMs) {
        return  // 还没到检测时间
      }

      const obj = info.weakRef.deref()
      if (obj === undefined) {
        // ✅ 对象已被回收
        console.info(`[LeakCanary] ✅ 已回收: ${tag}`)
        toRemove.push(tag)
      } else {
        // 🔴 疑似泄漏
        const leakInfo: LeakInfo = {
          tag,
          description: info.description,
          createdAt: info.createdAt,
          detectedAt: now,
          stackTrace: info.stackTrace
        }
        this.leakHistory.push(leakInfo)

        // 触发泄漏回调
        if (this.config.onLeakDetected) {
          this.config.onLeakDetected(leakInfo)
        }

        console.error(`[LeakCanary] 🔴 检测到泄漏: ${tag} - ${info.description}`)
        console.error(`[LeakCanary] 创建调用栈:\n${info.stackTrace}`)

        toRemove.push(tag)
      }
    })

    // 清理已检测的条目
    toRemove.forEach(tag => this.pendingChecks.delete(tag))
  }

  // 捕获调用栈
  private captureStackTrace(): string {
    try {
      // ArkTS中获取调用栈的方式
      return new Error().stack || '调用栈不可用'
    } catch {
      return '调用栈不可用'
    }
  }

  // 获取泄漏历史
  getLeakHistory(): LeakInfo[] {
    return [...this.leakHistory]
  }

  // 获取检测报告
  getReport(): string {
    const result = this.detector.checkAll()
    let report = '╔══════════════════════════════════════╗\n'
    report += '║   HarmonyLeakCanary 检测报告         ║\n'
    report += '╚══════════════════════════════════════╝\n\n'
    report += `📊 追踪中: ${this.pendingChecks.size}\n`
    report += `🔴 泄漏总数: ${this.leakHistory.length}\n`
    report += `✅ 已回收: ${result.collected.length}\n\n`

    if (this.leakHistory.length > 0) {
      report += '--- 泄漏详情 ---\n'
      this.leakHistory.forEach((info, index) => {
        report += `\n[${index + 1}] ${info.tag}\n`
        report += `    描述: ${info.description}\n`
        report += `    创建时间: ${new Date(info.createdAt).toLocaleString()}\n`
        report += `    检测时间: ${new Date(info.detectedAt).toLocaleString()}\n`
        report += `    存活时长: ${((info.detectedAt - info.createdAt) / 1000).toFixed(1)}秒\n`
      })
    }

    return report
  }

  // 清空泄漏历史
  clearHistory(): void {
    this.leakHistory = []
  }
}

// ===== 在应用中集成 =====
@Entry
@Component
struct LeakDetectionDemoPage {
  private leakCanary: HarmonyLeakCanary = HarmonyLeakCanary.getInstance()
  @State leakReport: string = '等待检测...'
  @State isMonitoring: boolean = false

  aboutToAppear(): void {
    // 初始化LeakCanary
    this.leakCanary.init({
      enabled: true,
      checkIntervalMs: 3000,
      watchDelayMs: 2000,
      onLeakDetected: (info: LeakInfo) => {
        // 泄漏检测回调 - 可以上报到监控平台
        console.error(`[App] 检测到内存泄漏: ${info.tag}`)
        this.leakReport = this.leakCanary.getReport()
      }
    })
    this.isMonitoring = true
  }

  build() {
    Scroll() {
      Column({ space: 16 }) {
        Text('🔍 HarmonyLeakCanary')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)

        // 泄漏监控状态
        Row({ space: 12 }) {
          Circle({ width: 12, height: 12 })
            .fill(this.isMonitoring ? '#4CAF50' : '#999999')
          Text(this.isMonitoring ? '监控中' : '已停止')
            .fontSize(14)
        }

        // 操作按钮
        Button('模拟闭包泄漏')
          .onClick(() => this.simulateClosureLeak())

        Button('模拟定时器泄漏')
          .onClick(() => this.simulateTimerLeak())

        Button('生成检测报告')
          .onClick(() => {
            this.leakReport = this.leakCanary.getReport()
          })

        Button('清空历史')
          .backgroundColor('#FF5722')
          .onClick(() => {
            this.leakCanary.clearHistory()
            this.leakReport = '历史已清空'
          })

        // 报告展示
        Scroll() {
          Text(this.leakReport)
            .fontSize(12)
            .fontFamily('monospace')
        }
        .height(300)
        .width('100%')
        .padding(8)
        .backgroundColor('#1E1E1E')
        .borderRadius(8)
      }
      .padding(16)
    }
  }

  // 模拟闭包泄漏
  private simulateClosureLeak(): void {
    const largeData = new Array(10000).fill('leak_data_string')
    const capturedRef = { data: largeData }

    // 注册到泄漏检测器
    this.leakCanary.watch(capturedRef, 'ClosureLeak', '闭包捕获的大数据对象')

    // 模拟闭包持有引用（故意不释放）
    const leakyCallback = () => {
      console.info(`[Leak] 数据长度: ${capturedRef.data.length}`)
    }
    globalEventBus.on('leaky_event', leakyCallback)
  }

  // 模拟定时器泄漏
  private simulateTimerLeak(): void {
    const timerData = { timestamp: Date.now(), payload: new Array(5000).fill('timer_data') }
    this.leakCanary.watch(timerData, 'TimerLeak', '定时器持有的大数据对象')

    // 故意不保存timerId，无法清理
    setInterval(() => {
      console.info(`[Leak] 定时器运行中: ${timerData.timestamp}`)
    }, 1000)
  }
}

// 全局事件总线（简化版）
const globalEventBus = {
  listeners: new Map<string, Array<() => void>>(),
  on(event: string, cb: () => void) {
    const list = this.listeners.get(event) || []
    list.push(cb)
    this.listeners.set(event, list)
  },
  off(event: string) {
    this.listeners.delete(event)
  }
}

四、踩坑与注意事项

坑点1：WeakRef.deref()返回undefined不一定就是泄漏

在某些情况下，WeakRef.deref()返回undefined可能只是因为GC还没有来得及运行，而不是对象真的被回收了。反之，在检测时间点对象仍然存在，也可能只是因为GC还没运行，不代表一定泄漏。

正确做法：在检测前手动建议GC运行（调试模式下可用），并设置合理的等待时间（建议3-5秒）。多次检测同一对象，如果持续存在才判定为泄漏。

坑点2：闭包中的this绑定陷阱

ArkTS中箭头函数的this绑定是词法作用域，这意味着在组件方法中使用箭头函数作为回调时，this会自动绑定到组件实例。如果这个回调被长生命周期对象持有，组件就无法被回收。

正确做法：使用普通函数或在回调中避免引用this，或者确保在组件销毁时注销回调。

坑点3：FinalizationRegistry的时序问题

FinalizationRegistry可以监听对象的GC回收事件，但回调的执行时机是不确定的——可能在对象被回收后很久才触发。不要依赖FinalizationRegistry来做关键的业务逻辑，它只适合做辅助性的资源清理。

坑点4：@State/@Link装饰器的隐式引用

被@State或@Link装饰的变量会被框架内部持有引用。如果你把一个组件实例赋值给@State变量，即使你手动置为null，框架内部可能仍然持有引用。

正确做法：不要将组件实例存储在@State变量中。如果必须存储引用，使用@Prop或普通变量，并确保在适当时机置null。

坑点5：异步操作中的泄漏

async/await和Promise中的异常处理如果不完善，可能导致回调一直挂起，持有的引用无法释放。特别是在网络请求超时或异常时，如果没有正确的try-catch-finally处理，资源可能泄漏。

正确做法：所有异步操作都使用try-finally确保资源释放，设置合理的超时时间。

坑点6：检测框架本身的内存开销

泄漏检测框架本身也会占用内存——每个追踪对象都需要存储WeakRef和元数据。如果在生产环境中追踪过多对象，检测框架本身可能成为内存问题。

正确做法：生产环境中只追踪关键对象（如页面组件、大缓存），开发环境中可以全量追踪。通过配置开关控制检测粒度。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. WeakRef性能优化：HarmonyOS 6对WeakRef的deref()操作进行了优化，查询延迟降低约30%，适合更高频率的泄漏检测。

2. GC策略变更：HarmonyOS 6默认启用增量式GC，GC暂停时间更短但总GC时间可能略增。这对泄漏检测的影响是：对象可能更晚才被回收，需要适当延长检测等待时间。

3. FinalizationRegistry回调增强：回调中新增heldValue参数，可以在回调中获取注册时传入的关联值，便于定位泄漏对象。

适配代码

// HarmonyOS 6 泄漏检测适配
class LeakDetectorV6 {
  private finalizationRegistry: FinalizationRegistry<string> | null = null
  private weakRefs: Map<string, WeakRef<object>> = new Map()

  constructor() {
    // HarmonyOS 6: 使用FinalizationRegistry监听对象回收
    try {
      this.finalizationRegistry = new FinalizationRegistry((heldValue: string) => {
        // 对象被GC回收时的回调
        console.info(`[LeakDetectorV6] ✅ 对象已回收: ${heldValue}`)
        this.weakRefs.delete(heldValue)
      })
    } catch (e) {
      // HarmonyOS 5 兼容：FinalizationRegistry不可用时降级为轮询检测
      console.warn('[LeakDetectorV6] FinalizationRegistry不可用，降级为轮询模式')
    }
  }

  // 追踪对象
  watch(obj: object, tag: string): void {
    const weakRef = new WeakRef(obj)
    this.weakRefs.set(tag, weakRef)

    // HarmonyOS 6: 注册FinalizationRegistry
    if (this.finalizationRegistry) {
      this.finalizationRegistry.register(obj, tag)
    }

    // HarmonyOS 6: 手动触发GC加速检测（仅调试模式）
    try {
      if (typeof globalThis.gc === 'function') {
        globalThis.gc()
      }
    } catch {
      // 非调试模式，跳过
    }
  }

  // 检查泄漏状态
  checkLeaks(): string[] {
    const leaked: string[] = []
    this.weakRefs.forEach((weakRef, tag) => {
      if (weakRef.deref() !== undefined) {
        leaked.push(tag)
      }
    })
    return leaked
  }

  // HarmonyOS 6: 导出堆内存快照（调试模式）
  takeHeapSnapshot(filename: string): boolean {
    try {
      if (typeof debugger.takeHeapSnapshot === 'function') {
        debugger.takeHeapSnapshot(filename)
        console.info(`[LeakDetectorV6] 堆快照已保存: ${filename}`)
        return true
      }
    } catch {
      console.warn('[LeakDetectorV6] 堆快照功能不可用')
    }
    return false
  }
}

六、总结

三维度评价表

核心收获：

1. 内存泄漏的本质是"该回收的对象因为隐式引用无法被GC回收"，理解引用链是检测泄漏的关键
2. 闭包、定时器、事件监听、组件引用、Native资源是最常见的五大泄漏场景
3. WeakRef是检测内存泄漏的核心工具，配合FinalizationRegistry可以实现自动化检测
4. HarmonyLeakCanary框架提供了从对象追踪到泄漏报告的完整检测链路
5. HarmonyOS 6在WeakRef性能、FinalizationRegistry回调、堆快照等方面有重要增强

一句话总结：内存泄漏就像水管上的暗漏——你看不到水在流，但水费账单会告诉你一切。构建一套自动化检测框架，就是在你的应用里装了一个智能水表，让每一滴"漏水"都无所遁形。