#跟着坚果学鸿蒙# HarmonyOS 5 使用TaskPool执行多个耗时任务的开发指南

技术无敌

11人浏览 · 2025-05-27 09:53:24

技术无敌 · 2025-05-27 09:53:24 发布

一、HarmonyOS 5 并发编程概述

在HarmonyOS 5应用开发中，高效处理耗时任务是提升应用性能的关键。ArkTS作为HarmonyOS官方推荐的语言，提供了强大的并发编程能力，其中TaskPool是一种轻量级的任务调度机制，能够显著优化应用性能。

1.1 TaskPool的核心优势

TaskPool基于线程池技术实现，具有以下特点：

自动线程管理：无需手动创建和销毁线程
任务优先级调度：支持高、中、低三种优先级
资源高效利用：动态调整线程数量
简化开发：通过简单API即可实现复杂并发逻辑

1.2 TaskPool与Worker的对比

特性	TaskPool	Worker
线程模型	线程池共享	独占线程
生命周期	自动管理	手动管理
适用场景	短时独立任务	长时/常驻任务
资源消耗	低	较高
任务调度	支持优先级	不支持

二、TaskPool基础使用

2.1 基本开发步骤

使用TaskPool执行任务只需三个步骤：

使用@Concurrent装饰器标记任务函数
通过TaskPool接口分发任务
在主线程接收处理结果

2.2 简单示例代码

// 定义一个并发任务函数
@Concurrent
function computeFactorial(n: number): number {
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

@Entry
@Component
struct TaskPoolExample {
  @State result: number = 0;

  async runTasks() {
    // 创建并执行任务
    const task = new taskpool.Task(computeFactorial, 10);
    
    // 获取任务结果
    this.result = await taskpool.execute(task);
    console.log(`Factorial result: ${this.result}`);
  }

  build() {
    Column() {
      Button('计算阶乘')
        .onClick(() => {
          this.runTasks();
        })
      Text(`结果: ${this.result}`)
        .fontSize(20)
        .margin(10)
    }
    .width('100%')
    .height('100%')
    .padding(20)
  }
}

三、高级TaskPool功能

3.1 任务组(TaskGroup)管理

当需要批量执行多个任务并统一等待结果时，TaskGroup是最佳选择。

@Concurrent
function processImage(data: ArrayBuffer): ArrayBuffer {
  // 模拟图像处理耗时操作
  for (let i = 0; i < data.byteLength; i++) {
    // 简单的图像处理逻辑
    if (i % 4 === 0) data[i] = 255 - data[i]; // 反色处理
  }
  return data;
}

@Entry
@Component
struct ImageProcessor {
  @State message: string = '准备处理';

  async processImages() {
    // 模拟3个图像数据块
    const imageData = new ArrayBuffer(1024 * 1024 * 3); // 3MB图像数据
    const chunkSize = imageData.byteLength / 3;
    
    // 创建任务组
    const taskGroup = new taskpool.TaskGroup();
    
    // 添加任务到组
    for (let i = 0; i < 3; i++) {
      const chunk = imageData.slice(i * chunkSize, (i + 1) * chunkSize);
      taskGroup.addTask(new taskpool.Task(processImage, chunk));
    }
    
    // 执行任务组并等待所有任务完成
    this.message = '处理中...';
    const results = await taskpool.execute(taskGroup);
    
    // 合并处理结果
    const processedData = new Uint8Array(imageData.byteLength);
    for (let i = 0; i < results.length; i++) {
      const resultChunk = new Uint8Array(results[i]);
      processedData.set(resultChunk, i * chunkSize);
    }
    
    this.message = `处理完成，共处理 ${processedData.length} 字节`;
  }

  build() {
    Column() {
      Button('并行处理图像')
        .onClick(() => {
          this.processImages();
        })
      Text(this.message)
        .fontSize(16)
        .margin(10)
    }
    .width('100%')
    .height('100%')
    .padding(20)
  }
}

3.2 长时任务处理

对于执行时间较长的任务，TaskPool提供了长时任务机制。

@Concurrent
async function longRunningTask(controller: taskpool.LongTaskController) {
  for (let i = 0; i < 100; i++) {
    // 定期发送进度数据
    await controller.sendData({progress: i});
    // 模拟耗时操作
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  return '任务完成';
}

@Entry
@Component
struct LongTaskExample {
  @State progress: number = 0;
  @State status: string = '准备开始';

  async startLongTask() {
    const longTask = new taskpool.LongTask(longRunningTask);
    
    // 设置数据接收回调
    longTask.onReceiveData((data: any) => {
      this.progress = data.progress;
      this.status = `处理中: ${this.progress}%`;
    });
    
    // 执行长时任务
    this.status = '任务启动...';
    const result = await taskpool.execute(longTask);
    
    this.status = result;
    this.progress = 100;
  }

  build() {
    Column() {
      Progress({value: this.progress, total: 100})
        .width('80%')
        .margin(10)
      Text(this.status)
        .fontSize(16)
        .margin(10)
      Button('启动长时任务')
        .onClick(() => {
          this.startLongTask();
        })
    }
    .width('100%')
    .height('100%')
    .padding(20)
  }
}

四、实际应用案例：图片加载器

下面是一个完整的图片加载器示例，展示如何利用TaskPool并行加载多张图片。

// 定义图片资源URL数组
const IMAGE_URLS = [
  'https://example.com/image1.jpg',
  'https://example.com/image2.jpg',
  'https://example.com/image3.jpg',
  'https://example.com/image4.jpg'
];

// 并发加载单张图片
@Concurrent
async function loadImage(url: string): Promise<ImageBitmap> {
  const response = await fetch(url);
  const blob = await response.blob();
  return await createImageBitmap(blob);
}

@Entry
@Component
struct ImageLoader {
  @State images: ImageBitmap[] = [];
  @State loading: boolean = false;
  @State progress: number = 0;

  async loadAllImages() {
    this.loading = true;
    this.progress = 0;
    
    const taskGroup = new taskpool.TaskGroup();
    
    // 为每张图片创建加载任务
    IMAGE_URLS.forEach(url => {
      taskGroup.addTask(new taskpool.Task(loadImage, url));
    });
    
    try {
      // 执行所有任务
      const results = await taskpool.execute(taskGroup);
      
      // 更新UI
      this.images = results;
      this.loading = false;
      this.progress = 100;
    } catch (error) {
      console.error('图片加载失败:', error);
      this.loading = false;
    }
  }

  build() {
    Column() {
      if (this.loading) {
        Progress({value: this.progress, total: 100})
          .width('80%')
          .margin(10)
        Text('加载中...')
          .fontSize(16)
      } else {
        Button('加载所有图片')
          .onClick(() => {
            this.loadAllImages();
          })
      }
      
      // 显示加载的图片
      Grid() {
        ForEach(this.images, (image: ImageBitmap) => {
          GridItem() {
            Image(image)
              .width(100)
              .height(100)
              .objectFit(ImageFit.Cover)
          }
        })
      }
      .columnsTemplate('1fr 1fr')
      .rowsTemplate('1fr 1fr')
      .width('100%')
      .height('60%')
    }
    .width('100%')
    .height('100%')
    .padding(20)
  }
}