在 HarmonyOS 的 ArkTS 并发模型中，TaskPool 和 Worker 均基于 Actor 并发模型实现，线程间内存隔离，通过消息传递进行通信。但两者在底层调度机制、线程生命周期管理以及适用场景上存在显著差异。

一、 TaskPool 的底层调度机制

TaskPool 是系统管理的线程池，底层在 Worker 之上实现了调度器和 Worker 线程池，开发者无需手动管理线程实例的生命周期。

1. 动态扩缩容机制：TaskPool 默认启动并预留一个任务工作线程。当任务较多时，系统会根据任务数量和执行时间自动扩容；当长时间没有任务分发时，会采用“急涨缓停”的思想阶梯式缩容，以节约系统资源。工作线程的数量上限与设备的物理核数相关（例如8核设备，线程数上限大概为7-15左右）。
2. 多优先级调度算法：TaskPool 支持 HIGH、MEDIUM、LOW、IDLE 四种优先级。底层调度按照 5:5:1 的比例进行：每调用 5 个高优先级任务后会调用 1 个中优先级任务，每调用 5 个中优先级任务后调用 1 个低优先级任务，防止低优先级任务“饥饿”。IDLE 优先级仅在所有线程空闲时触发，且同一时间只执行一个。
3. 任务分发与依赖管理：主线程调用 execute 接口时，调度器会依据优先级和防饥饿算法从队列中取出任务，序列化后放入 Worker 线程池执行。此外，TaskPool 支持通过 addDependency / removeDependency 设置树状依赖，以及通过 SequenceRunner 实现串行顺序执行。

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

// 1. 定义顶层并发函数（必须使用 @Concurrent 装饰器）
@Concurrent
function heavyCompute(id: number): string {
  let sum: number = 0;
  for (let i = 0; i < 10000000; i++) {
    sum += i;
  }
  return `Task ${id} done: ${sum}`;
}

// 2. 演示多优先级调度与任务取消
async function priorityDemo() {
  // 创建高优先级任务（如 UI 强相关的计算）
  let highTask = new taskpool.Task(heavyCompute, 1);
  // 创建低优先级任务（如后台日志写入）
  let lowTask = new taskpool.Task(heavyCompute, 2);

  // 提交高优先级任务
  let highPromise = taskpool.execute(highTask, taskpool.Priority.HIGH);
  
  // 延迟提交低优先级任务
  setTimeout(() => {
    taskpool.execute(lowTask, taskpool.Priority.LOW);
    // 若不需要，可取消尚未执行的低优先级任务
    taskpool.cancel(lowTask); 
  }, 100);

  let result = await highPromise;
  console.info('High priority result: ' + result);
}

// 3. 演示串行队列（SequenceRunner）
async function sequenceDemo() {
  let runner = new taskpool.SequenceRunner();
  let task1 = new taskpool.Task(heavyCompute, 10);
  let task2 = new taskpool.Task(heavyCompute, 20);

  // 保证 task1 执行完毕后，再执行 task2
  runner.execute(task1).then(() => {
    console.info('Task 1 finished');
  });
  runner.execute(task2).then(() => {
    console.info('Task 2 finished');
  });
}

async function taskGroupDemo() {
  const group = new taskpool.TaskGroup();
  // 将多个任务添加到组中
  group.addTask(new taskpool.Task(heavyCompute, 100));
  group.addTask(new taskpool.Task(heavyCompute, 200));
  group.addTask(new taskpool.Task(heavyCompute, 300));

  // 执行整个任务组，等待所有任务完成，结果将以数组形式返回
  const results: string[] = await taskpool.execute(group) as string[];
  console.info('Task group results: ', results);
}

二、 Worker 的底层调度机制

Worker 是开发者手动创建和管理的独立线程，拥有独立的运行环境（包括内存空间、消息队列 MessageQueue、事件轮询机制 EventLoop 和调用栈 CallStack）。

1. 独立事件循环与消息通信：Worker 线程和宿主线程之间完全隔离，通过 postMessage 发送消息，底层采用结构化克隆算法（Structured Clone）进行数据的序列化与反序列化交互。
2. 生命周期与数量限制：Worker 的创建和销毁耗费较高性能（空任务内存占用约 2MB），因此系统严格限制同个进程下最多同时存在 64 个 Worker 线程。开发者必须自行管理 Worker 实例的创建、复用与销毁，避免内存泄漏或资源浪费。
3. 真正的多核并发：在多核 CPU 架构下，多个 Worker 线程可以被分配到不同的物理核心上同时执行，从而实现真正的并发计算。

1. Worker 线程脚本 (entry/ets/workers/ComputeWorker.ets)

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

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

// 监听主线程发来的消息
workerPort.onmessage = (e: MessageEvents) => {
  const { action, data } = e.data;
  if (action === 'compute') {
    // 模拟耗时计算
    let result = 0;
    for (let i = 0; i < data; i++) {
      result += i;
    }
    // 将结果回传给主线程
    workerPort.postMessage({ result: result });
  } else if (action === 'terminate') {
    workerPort.close();
  }
};

// 通知主线程 Worker 已就绪
workerPort.postMessage({ status: 'ready' });

2. 主线程 ArkUI 页面 (pages/Index.ets)

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

@Entry
@Component
struct WorkerDemo {
  @State resultText: string = '等待计算...';
  private myWorker: worker.ThreadWorker | null = null;

  aboutToAppear() {
    // 创建 Worker 实例（系统限制最多64个，注意内存开销）
    this.myWorker = new worker.ThreadWorker('entry/ets/workers/ComputeWorker.ets');
    
    // 接收 Worker 回传的消息
    this.myWorker.onmessage = (e: MessageEvents) => {
      if (e.data.status === 'ready') {
        this.resultText = 'Worker 就绪';
      } else if (e.data.result !== undefined) {
        this.resultText = `计算结果: ${e.data.result}`;
      }
    };
  }

  // ⚠️ 关键：页面销毁时必须终止 Worker，防止内存泄漏
  aboutToDisappear() {
    if (this.myWorker) {
      this.myWorker.postMessage({ action: 'terminate' });
      this.myWorker.terminate();
      this.myWorker = null;
    }
  }

  build() {
    Column({ space: 20 }) {
      Text(this.resultText).fontSize(20)
      Button('开始计算')
        .onClick(() => {
          // 向 Worker 发送计算指令
          this.myWorker?.postMessage({ action: 'compute', data: 10000000 });
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

三、 核心机制对比与选型

• TaskPool：适合执行短平快的耗时任务（CPU执行时长不超过3分钟）、I/O密集型任务（如本地日志写入）以及需要多任务优先级调度的场景。
• Worker：适合需要长期驻留后台的常驻任务、需要指定特定线程执行的业务，或执行超过3分钟的长时任务。

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

// TaskPool 适用场景：短平快任务，无需手动管理生命周期
@Concurrent
function quickTask(data: number): number {
  return data * 2;
}

async function taskPoolDemo() {
  const task = new taskpool.Task(quickTask, 10);
  const result = await taskpool.execute(task);
  console.info('TaskPool result:', result);
}

// Worker 适用场景：需要长期驻留后台的常驻任务
function workerDemo() {
  // 创建独立线程，需手动管理生命周期
  const myWorker = new worker.ThreadWorker('entry/ets/workers/MyWorker.ets');
  myWorker.postMessage({ command: 'start' });
  
  // 注意：任务结束后必须调用 myWorker.terminate() 释放资源
}

四、 TaskPool 高阶特性：任务组与依赖管理

在处理复杂的业务逻辑时，任务往往不是孤立的。TaskPool 提供了强大的任务编排能力。

• TaskGroup（任务组）：支持将多个独立任务打包为一个任务组统一提交。系统会并行执行组内任务，并在所有任务完成后返回聚合结果。这对于需要并发请求多个接口并等待全部返回的页面初始化场景极为适用。
• 树状依赖与串行队列：通过 addDependency 可构建复杂的任务依赖树；而 SequenceRunner 则允许开发者创建专属的串行队列，确保多个存在数据依赖的任务严格按照先进先出（FIFO）的顺序执行，避免并发状态冲突。

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

@Concurrent
function fetchData(id: number): string {
  // 模拟网络请求
  return `Data from API ${id}`;
}

@Concurrent
function mergeData(results: string[]): string {
  return `Merged: ${results.join(', ')}`;
}

async function advancedTaskPoolDemo() {
  // 1. 任务组（TaskGroup）：并发执行并聚合结果
  const group = new taskpool.TaskGroup();
  group.addTask(new taskpool.Task(fetchData, 1));
  group.addTask(new taskpool.Task(fetchData, 2));
  group.addTask(new taskpool.Task(fetchData, 3));
  
  const apiResults = await taskpool.execute(group) as string[];
  
  // 2. 树状依赖：mergeTask 必须等待所有 fetchData 任务完成后才能执行
  const mergeTask = new taskpool.Task(mergeData, apiResults);
  // 假设 task1, task2, task3 是上面的 fetchData 任务实例
  // mergeTask.addDependency(task1); 
  // mergeTask.addDependency(task2);
  
  const finalResult = await taskpool.execute(mergeTask);
  console.info('Final merged result:', finalResult);
}

五、 极致性能：零拷贝数据传输

在 Actor 模型中，线程间通信通常依赖序列化与反序列化，这在传输大体积数据（如图片像素数据、音视频 Buffer）时会带来巨大的 CPU 开销。

• ArrayBuffer 转移（Transfer）：TaskPool 和 Worker 均支持在传递 ArrayBuffer 时将其标记为“转移（Transfer）”状态。数据的所有权会从主线程直接转移到子线程，主线程中的引用立即失效。这种“零拷贝”机制彻底消除了内存复制的开销。
• SharedArrayBuffer 共享：对于需要多线程高频读写且频繁同步的数据，支持使用共享内存（SharedArrayBuffer），配合原子操作（Atomics）实现无锁并发控制。

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

@Concurrent
function processImage(buffer: ArrayBuffer): number {
  // 在子线程中直接操作 Buffer，无拷贝开销
  return buffer.byteLength;
}

async function zeroCopyDemo() {
  // 模拟 10MB 的图片像素数据
  const largeBuffer = new ArrayBuffer(10 * 1024 * 1024);
  
  const task = new taskpool.Task(processImage, largeBuffer);
  // 【核心优化】：将 ArrayBuffer 的控制权转移给子线程
  // 转移后，主线程的 largeBuffer 将失效（byteLength 变为 0）
  task.setTransferList([largeBuffer]); 
  
  const size = await taskpool.execute(task);
  console.info('Processed buffer size:', size);
  
  // 此时若访问 largeBuffer.byteLength 将得到 0，因为所有权已转移
}

六、 生命周期与资源防泄漏

并发编程极易引发内存泄漏与资源耗尽，必须建立严格的管控机制。

• TaskPool 缩容机制：系统每 30 秒检测一次负载，若线程空闲时长达到 30s、未执行长时任务且无业务句柄占用，系统会自动释放该工作线程。
• Worker 手动销毁：由于 Worker 内存占用较高（约 2MB/个），在任务执行完毕后，必须显式调用 worker.terminate() 销毁实例，否则会导致进程内存持续攀升。

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

@Entry
@Component
struct SafeWorkerPage {
  private myWorker: worker.ThreadWorker | null = null;

  aboutToAppear() {
    // 初始化 Worker
    this.myWorker = new worker.ThreadWorker('entry/ets/workers/HeavyWorker.ets');
    this.myWorker.onmessage = (e) => {
      console.info('Worker message:', e.data);
    };
  }

  // 【关键防线】：组件销毁时必须终止 Worker
  aboutToDisappear() {
    if (this.myWorker) {
      this.myWorker.terminate();
      this.myWorker = null;
    }
  }

  build() {
    Column() {
      Text('Worker Lifecycle Demo')
    }
  }
}

七、 并发选型与工程化最佳实践

• TaskPool 适用场景：图片/视频编解码、JSON 解析、复杂数学计算、批量 I/O 操作。开发者只需关注业务逻辑，无需关心线程创建与销毁。
• Worker 适用场景：后台持续的网络长连接监听、音频/视频流的实时处理、需要维持全局状态的后台服务。
• 避坑指南：TaskPool 的执行函数必须是模块顶层函数且使用 @Concurrent 装饰器，不能访问主线程的 UI 对象（如 AppStorage）；Worker 的消息处理需在 onmessage 中做好异常捕获，防止未捕获异常导致线程静默崩溃。