HarmonyOS鸿蒙Next中TaskPool和Worker业务场景有哪些？

TaskPool 和 Worker 都是 ArkTS 中用于实现多线程并发的手段，但它们的设计目标和适用场景有显著区别。

一、TaskPool（任务池）

核心思想：轻量级、高频、短时任务调度。系统管理一个线程池，开发者只需提交任务，由系统分配线程资源执行，无需关心线程的生命周期管理。适合执行次数多、耗时短（建议 < 3分钟）、无状态的任务。

典型业务场景 1：图像处理（如滤镜、缩放）

// 1. 定义图像处理任务（一个独立的函数，必须用@Concurrent装饰器标记）
import { taskpool } from '@kit.ArkTS';

@Concurrent
async function applyImageFilter(imageData: object): Promise<object> { // 使用object类型模拟像素数据
  // ... 这里是具体的图像滤镜算法（例如灰度化、高斯模糊）
  console.log("TaskPool: Processing image in background...");
  // 模拟耗时操作
  for (let i = 0; i < 100000000; i++) { }
  let filteredImage = imageData; // 此处应为处理后的结果
  return filteredImage;
}

// 2. 在主线程中提交任务到TaskPool
import { taskpool } from '@kit.ArkTS';
import { BusinessError } from '@kit.BasicServicesKit';

@Entry
@Component
struct ImageProcessPage {
  @State message: string = 'Hello World'

  aboutToAppear() {
    // 模拟一些图片数据
  }

  processSingleImage() {
    // 为处理任务创建一个Task对象，传入处理函数和参数
    let task: taskpool.Task = new taskpool.Task(applyImageFilter, {pixels: "mock_data"});
    
    // 将Task放入TaskPool执行，返回一个Promise
    taskpool.execute(task).then((filteredResult: object) => {
      // 处理完成后，更新UI，显示处理后的图片
      console.info('TaskPool: Image processed successfully.');
      this.message = 'Process Success!';
    }).catch((err: BusinessError) => {
      console.error(`TaskPool failed: ${err.message}`);
    });
  }

  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
        Button('Process Image with TaskPool')
          .onClick(() => {
            this.processSingleImage();
          })
      }
      .width('100%')
    }
    .height('100%')
  }
}

典型业务场景 2：并行处理数组元素

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

@Concurrent
function processItem(item: number): number {
  // 对每个数组元素进行一些计算密集型操作
  return item * item;
}

@Entry
@Component
struct DataProcessPage {
  @State result: string = 'Results will appear here';

  processData() {
    let data: number[] = [1, 2, 3, 4, 5];
    let tasks: taskpool.Task[] = [];

    // 为每个数据项创建任务
    for (let i = 0; i < data.length; i++) {
      let task: taskpool.Task = new taskpool.Task(processItem, data[i]);
      tasks.push(task);
    }

    // 使用TaskGroup执行所有任务
    let taskGroup: taskpool.TaskGroup = new taskpool.TaskGroup();
    taskGroup.addTasks(tasks);

    taskpool.execute(taskGroup).then((results: Object[]) => {
      let resultStr: string = 'Results: ' + (results as number[]).join(', ');
      console.info('TaskPool Group Execution Success: ' + resultStr);
      this.result = resultStr;
    }).catch((err: BusinessError) => {
      console.error(`TaskPool Group failed: ${err.message}`);
    });
  }

  build() {
    Row() {
      Column() {
        Text(this.result)
        Button('Process Array with TaskPool Group')
          .onClick(() => {
            this.processData();
          })
      }
      .width('100%')
    }
    .height('100%')
  }
}

二、Worker

核心思想：重量级、长时、有状态任务。开发者需要创建一个独立的线程（Worker），并与之进行通信。适合执行长时间（可能超过3分钟）、需要保持状态或与主线程有复杂交互的任务。

典型业务场景 1：后台数据同步

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

// 获取Worker端口
const workerPort: worker.ThreadWorkerGlobalScope = worker.workerPort;

// 模拟长时间运行的任务，如网络请求和数据库操作
function performLongRunningSync(data: number): string {
  console.log("Worker: Sync started...");
  // 模拟一个长时间的操作（例如，网络下载、大量数据处理）
  for (let i = 0; i < 1000000000; i++) { }
  console.log("Worker: Sync completed.");
  return `Processed data: ${data * 10}`;
}

// 监听主线程发来的消息
workerPort.onmessage = (e: MessageEvents): void => {
  console.info(`Worker: Received data from main thread: ${JSON.stringify(e.data)}`);
  if (e.data.type === 'startSync') {
    // 执行耗时操作
    let result: string = performLongRunningSync(e.data.payload);
    // 操作完成后，将结果发送回主线程
    workerPort.postMessage({
      status: 'success',
      result: result
    });
  } else if (e.data.type === 'stop') {
    console.info("Worker: Received stop command.");
    // Worker可以通过close()自行终止，或由主线程terminate()
    workerPort.close();
  }
}

// 监听错误事件
workerPort.onerror = (err: ErrorEvent): void => {
  console.error(`Worker: Error occurred: ${err.message}`);
}

典型业务场景 2：在主线程中创建并使用Worker

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

@Entry
@Component
struct MainPage {
  // 声明Worker实例
  private syncWorker: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/SyncWorker');
  @State message: string = 'Hello World';
  @State syncResult: string = '';

  aboutToAppear() {
    // 设置Worker的消息监听器
    this.syncWorker.onmessage = (e: MessageEvents): void => {
      console.info(`Main: Received message from worker: ${JSON.stringify(e.data)}`);
      this.syncResult = e.data.result;
      this.message = 'Sync Done!';
      // 根据业务逻辑决定是否终止Worker
      // this.syncWorker.terminate();
    }

    // 设置Worker的错误监听器
    this.syncWorker.onerror = (err: ErrorEvent): void => {
      console.error(`Main: Worker error: ${err.message}`);
    }
  }

  startBackgroundSync() {
    this.message = 'Syncing...';
    // 向Worker发送消息，启动同步任务，可以传递复杂数据
    this.syncWorker.postMessage({ type: 'startSync', payload: 42 });
  }

  stopWorker() {
    // 向Worker发送停止指令
    this.syncWorker.postMessage({ type: 'stop' });
  }

  aboutToDisappear() {
    // 页面销毁时，必须终止Worker以释放资源
    this.syncWorker.terminate();
  }

  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(30)
        Text(this.syncResult)
          .fontSize(20)
        Button('Start Sync with Worker')
          .onClick(() => {
            this.startBackgroundSync();
          })
        Button('Stop Worker')
          .onClick(() => {
            this.stopWorker();
          })
      }
      .width('100%')
    }
    .height('100%')
  }
}

三、选择总结与对比

决策指南：

• TaskPool: 处理大量独立的、短时的、无状态的任务（如图像批量处理、数组元素并行计算）。
• Worker: 处理单个或少量的、长时的、需要保持状态或复杂通信的任务（如后台下载、数据库同步、实时数据处理）。