HarmonyOS 鸿蒙Next Worker 线程反复创建几轮就崩了？Worker 生命周期管理与内存回收实战

建议不要“每张图创建一个 Worker，用完就 terminate”。图片缩放/压缩会碰到 native 内存、编解码缓存、线程运行时回收延迟，频繁建销毁很容易把 native heap 顶上去。

正确做法是 固定少量 Worker + 队列 + 每次任务清空 Worker 内部上下文。

主线程用 worker.ThreadWorker 创建 Worker，通过 postMessage 通信，任务完成后可 terminate()；Worker 是隔离线程，通过消息传递数据。相关文档：[@ohos.worker](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-worker)。

推荐结构

页面
  -> ImageWorkerPool
      -> 固定 1~2 个 Worker
      -> 任务排队
      -> 每个 Worker 同一时间只处理 1 个任务
      -> 页面销毁时统一 terminate

Index.ets

import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS';

class ImageJob {
  id: number = 0;
  buffer: ArrayBuffer = new ArrayBuffer(0);

  constructor(id: number, buffer: ArrayBuffer) {
    this.id = id;
    this.buffer = buffer;
  }
}

class WorkerResult {
  id: number = 0;
  size: number = 0;
  success: boolean = false;
  message: string = '';
}

@Entry
@Component
struct Index {
  @State private log: string = '等待处理';
  private workerInstance: worker.ThreadWorker | null = null;
  private nextId: number = 1;
  private isBusy: boolean = false;
  private queue: ImageJob[] = [];

  aboutToDisappear(): void {
    this.releaseWorker();
  }

  private ensureWorker(): void {
    if (this.workerInstance !== null) {
      return;
    }

    let instance = new worker.ThreadWorker('entry/ets/workers/ImageWorker.ets');

    instance.onmessage = (event: MessageEvents): void => {
      let result = event.data as WorkerResult;
      this.isBusy = false;
      this.log = `任务 ${result.id} 完成，压缩后大小：${result.size}`;
      this.runNext();
    };

    instance.onerror = (err: ErrorEvent): void => {
      this.isBusy = false;
      this.log = `Worker 错误：${err.message}`;
      this.runNext();
    };

    instance.onexit = (code: number): void => {
      console.info(`Worker exit: ${code}`);
    };

    this.workerInstance = instance;
  }

  private addMockImage(): void {
    let id = this.nextId;
    this.nextId += 1;

    // 示例用 ArrayBuffer 模拟图片原始数据。真实业务里可传图片路径或 URI，避免大对象频繁复制。
    let buffer = new ArrayBuffer(1024 * 1024 * 4);
    this.queue.push(new ImageJob(id, buffer));
    this.log = `已加入任务 ${id}，队列长度：${this.queue.length}`;
    this.runNext();
  }

  private runNext(): void {
    if (this.isBusy) {
      return;
    }

    if (this.queue.length === 0) {
      return;
    }

    this.ensureWorker();

    let instance = this.workerInstance;
    if (instance === null) {
      return;
    }

    let job = this.queue.shift();
    if (job === undefined) {
      return;
    }

    this.isBusy = true;
    this.log = `正在处理任务 ${job.id}`;

    // 大 ArrayBuffer 建议转移所有权，减少主线程和 Worker 间复制。
    instance.postMessage(job, [job.buffer]);
  }

  private releaseWorker(): void {
    if (this.workerInstance !== null) {
      this.workerInstance.terminate();
      this.workerInstance = null;
    }

    this.queue.splice(0, this.queue.length);
    this.isBusy = false;
  }

  build() {
    Column({ space: 16 }) {
      Text(this.log)
        .fontSize(16)

      Button('模拟选择一张图片')
        .onClick(() => {
          this.addMockImage();
        })

      Button('释放 Worker')
        .onClick(() => {
          this.releaseWorker();
          this.log = 'Worker 已释放';
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

ImageWorker.ets

import { worker, MessageEvents, ErrorEvent, ThreadWorkerGlobalScope } from '@kit.ArkTS';

class ImageJob {
  id: number = 0;
  buffer: ArrayBuffer = new ArrayBuffer(0);
}

class WorkerResult {
  id: number = 0;
  size: number = 0;
  success: boolean = false;
  message: string = '';
}

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (event: MessageEvents): void => {
  let job = event.data as ImageJob;

  // 关键：每次任务都创建新的局部上下文，不复用上一次的临时变量。
  let input: Uint8Array = new Uint8Array(job.buffer);
  let outputSize: number = Math.floor(input.byteLength / 2);

  let result = new WorkerResult();
  result.id = job.id;
  result.size = outputSize;
  result.success = true;
  result.message = 'ok';

  workerPort.postMessage(result);

  // 真实图片处理时，这里要释放 imageSource、pixelMap、packer 等 native 资源。
  // 不要把大数组、PixelMap、ImageSource 放到模块级变量里缓存。
};

workerPort.onerror = (err: ErrorEvent): void => {
  console.error(`ImageWorker error: ${err.message}`);
};

build-profile.json5

{
  "buildOption": {
    "sourceOption": {
      "workers": [
        "./src/main/ets/workers/ImageWorker.ets"
      ]
    }
  }
}

你当前观测到的三类现象成因如下：

1. 调用 terminate() 后原生堆内存未立即回落：属于正常表现。线程持续运行、图像编解码产生的原生对象、内存分配器缓存均会造成内存延迟回收；高频新建 Worker 会进一步加剧该现象。
2. 加载至第 10 张图前后触发 OOM：核心诱因多为并发 Worker 数量超限、原图数据存在冗余拷贝、PixelMap/ImageSource/Packer 资源未主动释放，或是事件回调闭包持续持有巨型内存对象。
3. Worker 复用后存在变量残留：根源是任务状态存储在 Worker 文件的模块级全局变量中。Worker 复用场景下进程不会重启，模块级变量会持续保留上一轮数据；业务任务数据建议仅存于 onmessage 局部作用域，或每次执行任务前手动重置状态。

这个问题其实很多图片处理、音视频处理场景都会遇到，主要不是 terminate() 没调用，而是 Worker 的资源释放机制和大对象生命周期没有处理好。

当前现象：

Worker创建 → 图片压缩 → terminate → 内存一直涨

第一个，terminate 后 native heap 不马上降

这个是正常现象。

Worker 里面如果处理：

• PixelMap
• ArrayBuffer
• 大 Uint8Array
• 图片缓存

这些很多是在 native 层申请的。

worker.terminate() 只是结束线程，不代表 native 内存马上归还给系统。

所以 Profiler 看到：

Worker没了，但是 heap还高

不一定代表泄漏。

重点看：

多轮执行后是否持续增长。

如果一直涨，说明有引用没释放。

第二个，处理十几张直接 OOM

你的方案：

一张图 → 创建 Worker → 压缩 → terminate

其实压力比较大。

因为每次：

• 创建线程
• 加载 worker上下文
• 初始化运行环境
• 申请图片内存
• 释放

反复几十次，很容易产生内存碎片。

图片压缩建议：

不要一个图片一个 Worker。

改用以下方案：

• 创建 Worker池：
  • 启动2~3个Worker
  • 图片任务排队：
    • 图片1 → Worker1
    • 图片2 → Worker2
  • 完成后继续复用。

第三个，Worker复用变量残留

这个也正常。

Worker不是函数调用。

它是一个长期运行环境。

比如：

let result = []

onmessage = () => {
   result.push(...)
}

第二次执行：

result还存在。

所以每次任务开始：

主动清理状态。

比如：

onmessage = (msg) => {
   let temp = []
   //处理
   temp = null
}

不要把任务数据挂在全局。

图片场景还要注意：

• 不要直接传大对象。
• 比如：PixelMap / ArrayBuffer
• 尽量：
  • 传路径
  • Worker内部读取
  • 或者用 Transferable 转移所有权。
• 否则：
  • 主线程一份
  • Worker一份
  • 内存直接翻倍。

比较稳定的架构：

• 主线程
  • → Worker池（2~3个）
  • → 单任务处理
  • → 返回结果
  • → 清理临时变量

不要：

每张图片创建Worker。

目前你的情况大概率是：

频繁创建Worker + 图片native内存释放滞后 + 大对象复制

三个叠加导致的。

先改Worker复用，通常 OOM 就会明显改善。

希望可以帮到你~~~