鸿蒙给了两套并发方案,TaskPool 和 Worker。官方的说法是"TaskPool 适合短时任务,Worker 适合长时任务",但这句话太短,实际写的时候还是不知道该怎么定。
这篇按三条线拆:任务活多久、要不要回传中间结果、失败了怎么收尾。三个问题答完,选择就唯一了。
它们不是"同一种东西的两个版本",机制上完全不同:
TaskPool 是线程池。你提交一个任务,系统从池子里拿一个空闲线程去跑,跑完回收。线程的创建、销毁、复用都由系统管,你不用管。
Worker 是独立线程。你自己 new 一个出来,它有自己的 postMessage 通道,跑什么、跑多久、什么时候销毁,都是你决定。
这个差别带来一个直接结果:TaskPool 里不能有长期驻留的状态。任务函数是纯函数式的,跑完就结束,不存在"记住上一次的中间变量"。Worker 可以,它是个长期存在的线程,你可以让它在里面挂着等消息。
秒级、跑完就结束 → TaskPool。
典型场景:解析一段 JSON、算一个哈希、压缩一张图片、批量格式化数据。这类任务的特点是"输入进去、结果出来",中间不需要和外面通信。
@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 长连接的后台逻辑。
// 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 省事的地方。
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。
let globalConfig = { retry: 3 };
@Concurrent
function doWork(data: string): string {
// ❌ 编译报错:不能访问 globalConfig
return data + globalConfig.retry;
}TaskPool 的函数是在另一个线程里执行的,它看不到主线程的变量。所有需要的数据必须通过参数传进去。
正确写法:
@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 的代码要放在单独的 .ets 文件里,通过 new worker.ThreadWorker('entry/ets/workers/my.ets') 加载。路径是相对于模块根目录的,写错会报"找不到模块"。
这个文件路径在打包后会变,所以不要拼绝对路径。
// ❌ 每次调用都新建一个线程
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(),否则页面退出后线程还挂着。
跟 TaskPool 一样,Worker 消息传输也是结构化克隆。传一个大对象过去,实际发生了一次完整拷贝。数据量大的时候,拷贝本身比计算更耗时。这种情况改用 ArrayBuffer 的转移(transfer)语义,或者把数据放在共享内存里。
Worker 里不能直接改 @State。算完 postMessage 回主线程,主线程收到后再改。
// 主线程
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 文件 |
想省事的程度 | 更省事 | 更可控但更啰嗦 |
决策流程:
这两个东西的选择,本质上不是技术选型,是对任务形态的判断。写代码前先把这个问题答清楚:这个任务是一次性的,还是持续的?答对了,选哪个都顺手;答错了,用哪个都别扭——比如拿 TaskPool 去跑长任务会被超时杀掉,拿 Worker 去跑一堆短任务会不停新建线程。
如果你想看这两个在真实业务里怎么落地——比如一个带进度的批量处理该怎么切、错误通道怎么设计,可以看看誉天教育的鸿蒙课,它第二阶段讲多端全栈的时候,服务端和客户端的任务调度是一起讲的,并发这块不是单独抽出来讲语法。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。