首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >鸿蒙的并发任务:TaskPool 和 Worker 该怎么选

鸿蒙的并发任务:TaskPool 和 Worker 该怎么选

原创
作者头像
权哥说IT
发布于 2026-11-16 12:56:25
发布于 2026-11-16 12:56:25
170
举报

鸿蒙给了两套并发方案,TaskPool 和 Worker。官方的说法是"TaskPool 适合短时任务,Worker 适合长时任务",但这句话太短,实际写的时候还是不知道该怎么定。

这篇按三条线拆:任务活多久、要不要回传中间结果、失败了怎么收尾。三个问题答完,选择就唯一了。

一、先看这两个东西根本不同的地方

它们不是"同一种东西的两个版本",机制上完全不同:

TaskPool 是线程池。你提交一个任务,系统从池子里拿一个空闲线程去跑,跑完回收。线程的创建、销毁、复用都由系统管,你不用管。

Worker 是独立线程。你自己 new 一个出来,它有自己的 postMessage 通道,跑什么、跑多久、什么时候销毁,都是你决定。

这个差别带来一个直接结果:TaskPool 里不能有长期驻留的状态。任务函数是纯函数式的,跑完就结束,不存在"记住上一次的中间变量"。Worker 可以,它是个长期存在的线程,你可以让它在里面挂着等消息。

二、三条判断线

第一线:任务的生命周期

秒级、跑完就结束 → TaskPool。

典型场景:解析一段 JSON、算一个哈希、压缩一张图片、批量格式化数据。这类任务的特点是"输入进去、结果出来",中间不需要和外面通信。

代码语言:typescript
复制
@Concurrent
function parseBigJson(raw: string): number {
 const obj = JSON.parse(raw);
 return obj.items.length;
}

async function countItems(raw: string): Promise<number> {
 const task = new taskpool.Task(parseBigJson, raw);
 return await taskpool.execute(task) as number;
}

注意 @Concurrent 这个装饰器。只有加了它的函数才能进 TaskPool,这是编译期检查,不加会报错。

分钟级、要一直活着 → Worker。

典型场景:实时音视频处理、持续的数据采集、需要保持 WebSocket 长连接的后台逻辑。

代码语言:typescript
复制
// worker.ts
import { worker, ThreadWorkerGlobalScope, MessageEvents } from '@kit.ArkTS';

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (e: MessageEvents) => {
 const cmd = e.data as string;
 if (cmd === 'start') {
 // 启动一个持续采集
 workerPort.postMessage({ type: 'tick', ts: Date.now() });
 }
};

Worker 的价值在于它能保持状态:一个连接对象、一个缓冲区、一个累加器,这些东西可以跨多次消息存在。

第二线:要不要回传中间结果

这一条经常被忽略,但它能直接排除掉一个选项。

TaskPool 只有一次回传:任务跑完,await 拿到结果。中间过程拿不到。

如果你的任务是"下载 100 个文件,每下完一个更新进度条",用 TaskPool 就很别扭——你只能在最后拿到一个结果数组,中间的进度无从得知。

Worker 可以随时 postMessage,中间结果想发几次发几次。

不过 TaskPool 也不是完全没办法:可以用 task.onProgressUpdate(API 11+ 支持)配合 taskpool.Task 的进度上报。但这属于后补的能力,天然不如 Worker 顺手。

判断法:如果界面上有一个跟着任务推进的进度条,优先考虑 Worker。

第三线:失败了怎么办

TaskPool 的失败会以 Promise reject 的形式回到调用方,你在 try/catch 里处理,跟普通的 async 函数一样。这是它比 Worker 省事的地方。

代码语言:typescript
复制
try {
 const result = await taskpool.execute(task);
} catch (err) {
 console.error(`任务失败: ${(err as BusinessError).message}`);
}

Worker 的失败要靠自己在 onmessage 里约定。线程里的异常不会自动抛回主线程,你得在 worker 内部 try/catch,然后 postMessage({type:'error', msg}) 回主线程。忘了这一步,Worker 崩了主线程完全不知道,只表现为"数据不再更新了"。

这一条决定了:如果团队里没人愿意为 Worker 写一套错误通道,就用 TaskPool。

三、TaskPool 的四个实际坑

坑一:@Concurrent 函数不能访问外部变量

代码语言:typescript
复制
let globalConfig = { retry: 3 };

@Concurrent
function doWork(data: string): string {
 // ❌ 编译报错:不能访问 globalConfig
 return data + globalConfig.retry;
}

TaskPool 的函数是在另一个线程里执行的,它看不到主线程的变量。所有需要的数据必须通过参数传进去。

正确写法:

代码语言:typescript
复制
@Concurrent
function doWork(data: string, retry: number): string {
 return data + retry;
}

taskpool.execute(new taskpool.Task(doWork, 'abc', 3));

这个限制很硬,而且它会把你的函数签名撑得很长。如果不方便每次都把配置摊开传,说明这个任务不适合 TaskPool。

坑二:参数和返回值必须可序列化

TaskPool 在线程间传数据靠结构化克隆。能传:number、string、boolean、Array、Map、Set、普通对象、ArrayBuffer。不能传:函数、类实例的方法、Context、UI 组件引用、Symbol。

踩过的一个具体例子:想把 UIContext 传进 TaskPool 去更新 UI,编译能过,运行时直接失败。UI 只能在主线程改,TaskPool 里算完必须回主线程再更新。

坑三:并发上限

TaskPool 默认的线程数是有上限的(跟设备核数相关)。一次 execute 几百个任务,后面的会排队。不要用 TaskPool 去跑几百个并行的网络请求,这时候该做的是合并请求,不是加线程。

坑四:长任务会被判定超时

TaskPool 有超时机制。一个任务跑太久(默认 3 分钟量级,可配置),会被强制终止。这条直接决定了 TaskPool 不适合跑长任务——这不是性能问题,是设计定位。

四、Worker 的四个实际坑

坑一:Worker 文件必须单独

Worker 的代码要放在单独的 .ets 文件里,通过 new worker.ThreadWorker('entry/ets/workers/my.ets') 加载。路径是相对于模块根目录的,写错会报"找不到模块"。

这个文件路径在打包后会变,所以不要拼绝对路径。

坑二:一次 new 一个,不要循环 new

代码语言:typescript
复制
// ❌ 每次调用都新建一个线程
function startJob() {
 const w = new worker.ThreadWorker('entry/ets/workers/job.ets');
 w.postMessage('run');
}

// ✅ 复用一个
let jobWorker: worker.ThreadWorker | null = null;

function startJob() {
 if (!jobWorker) {
 jobWorker = new worker.ThreadWorker('entry/ets/workers/job.ets');
 }
 jobWorker.postMessage('run');
}

每个 Worker 都是一个真实线程,循环 new 会迅速耗尽线程资源。用完记得 terminate(),否则页面退出后线程还挂着。

坑三:onmessage 的数据也是拷贝

跟 TaskPool 一样,Worker 消息传输也是结构化克隆。传一个大对象过去,实际发生了一次完整拷贝。数据量大的时候,拷贝本身比计算更耗时。这种情况改用 ArrayBuffer 的转移(transfer)语义,或者把数据放在共享内存里。

坑四:UI 更新必须回主线程

Worker 里不能直接改 @State。算完 postMessage 回主线程,主线程收到后再改。

代码语言:typescript
复制
// 主线程
worker.onmessage = (e: MessageEvents) => {
 this.progress = e.data.progress; // ✅ 这里改 @State 才对
};

五、还有第三条路:不用并发

这一条必须说,因为很多人是被"性能"两个字吓到才上并发的。

判断是不是真的需要并发,先看主线程在干什么。

如果卡顿的原因是"一次处理了 10MB 的 JSON",那是计算密集,该上并发。如果卡顿的原因是"列表一次渲染了 2000 条",那是渲染问题,该做的是 LazyForEach 加虚拟化,不是开线程。

如果卡顿的原因是"同步文件读写",那应该先看能不能换成异步 API(fs.readText 而不是 fs.readTextSync),异步 API 本来就不阻塞主线程,根本不需要 Worker。

并发的成本是可见的:线程要占内存、通信要序列化、错误要多写一套通道、调试要多开一个上下文。这些成本只有在"确实有一段长时间的 CPU 计算"时才值得。

一句话:先确认瓶颈在 CPU,再上并发。别拿线程去救渲染问题。

六、选择表

判断项

TaskPool

Worker

任务时长

秒级,最长几分钟

分钟级以上,或长期驻留

是否要保留状态

不能

能

中间进度回传

弱(需 onProgressUpdate)

强,随时 postMessage

错误回传

自动 reject,try/catch 即可

需自己约定错误消息

代码组织

一个 @Concurrent 函数

一个独立 .ets 文件

想省事的程度

更省事

更可控但更啰嗦

决策流程:

  1. 这段计算需要几分钟以上、或者需要一直活着?→ Worker
  2. 需要中途不断回传进度?→ 优先 Worker
  3. 只是"算一下、给个结果"?→ TaskPool
  4. 不确定要不要并发?→ 先不并发,去查瓶颈

七、最后一句

这两个东西的选择,本质上不是技术选型,是对任务形态的判断。写代码前先把这个问题答清楚:这个任务是一次性的,还是持续的?答对了,选哪个都顺手;答错了,用哪个都别扭——比如拿 TaskPool 去跑长任务会被超时杀掉,拿 Worker 去跑一堆短任务会不停新建线程。

如果你想看这两个在真实业务里怎么落地——比如一个带进度的批量处理该怎么切、错误通道怎么设计,可以看看誉天教育的鸿蒙课,它第二阶段讲多端全栈的时候,服务端和客户端的任务调度是一起讲的,并发这块不是单独抽出来讲语法。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

目录
  • 一、先看这两个东西根本不同的地方
  • 二、三条判断线
    • 第一线:任务的生命周期
    • 第二线:要不要回传中间结果
    • 第三线:失败了怎么办
  • 三、TaskPool 的四个实际坑
    • 坑一:@Concurrent 函数不能访问外部变量
    • 坑二:参数和返回值必须可序列化
    • 坑三:并发上限
    • 坑四:长任务会被判定超时
  • 四、Worker 的四个实际坑
    • 坑一:Worker 文件必须单独
    • 坑二:一次 new 一个,不要循环 new
    • 坑三:onmessage 的数据也是拷贝
    • 坑四:UI 更新必须回主线程
  • 五、还有第三条路:不用并发
  • 六、选择表
  • 七、最后一句
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档