问题解答

Q1：批量处理 1000 张图片导致网络请求卡住，是不是线程池满了？

答：是的，极大概率是线程池资源耗尽或调度队列堵塞。 虽然 TaskPool 允许添加大量任务到队列中（理论无硬上限），但同时运行的工作线程数是有限的（与 CPU 核数相关）。当你一次性提交 1000 个任务：

1. 调度阻塞：所有工作线程都被瞬间占满，后续的网络请求回调、I/O 任务如果没有独立的线程处理，就需要等待 TaskPool 释放资源，导致“卡住”的现象。
2. 资源竞争：大量任务同时序列化/反序列化、申请内存，会引发频繁 GC 和 CPU 抢占，进一步拖慢系统响应。

Q2：系统默认最大线程数是多少？

答：系统没有承诺一个固定的“最大线程数”，它是动态调整的。

• 机制：TaskPool 会根据任务负载和当前设备的物理核数自动进行扩容或缩容。
• 上限：通常与设备的 CPU 核心数强相关（例如 8 核设备，工作线程数通常是个位数或十几个，绝不可能达到 1000）。
• 官方说明：官方明确指出“出于内存因素不建议创建过多任务”，且“不建议在任务中执行阻塞操作”。

建议方案：显式限流 + 读写分离

为了避免阻塞主线程和网络，建议将“CPU 密集型任务”与“I/O 任务”拆分，并分别限制并发数。

核心策略：

1. CPU 段（图像处理）：使用 TaskPool，但限制并发数（如 3-5 个），避免占满所有 CPU 核。
2. I/O 段（网络上传）：在宿主线程使用异步并发（Promise.all 配合限流），不要占用 TaskPool 线程。

代码示例（ArkTS）：

下面示例演示“CPU 用 TaskPool + 网络单独限流”的最小结构。你可以把它复制到工程里按业务替换 processImageInTaskPool 与 uploadImage。

import { taskpool } from '@kit.ArkTS'

export interface ImageItem {
  id: string
  srcPath: string
}

export interface ProcessedImage {
  id: string
  data: ArrayBuffer
}

export interface UploadResult {
  id: string
  ok: boolean
  remoteUrl: string
}

/**
 * 在 TaskPool 工作线程中执行的纯计算函数：将源图片处理为二进制结果。
 * 注意：不要在这里发网络请求或做长时间阻塞操作。
 */
@Concurrent
function processImageBytes(srcPath: string): ArrayBuffer {
  return new ArrayBuffer(0)
}

/**
 * 将 CPU 密集型图片处理下沉到 TaskPool 执行，并返回处理后的二进制结果。
 */
export async function processImageInTaskPool(srcPath: string): Promise<ArrayBuffer> {
  const task: taskpool.Task = new taskpool.Task(processImageBytes, srcPath)
  const result: Object = await taskpool.execute(task)
  return result as ArrayBuffer
}

/**
 * 对数组进行并发映射，显式控制并发度，避免一次性创建过多异步任务。
 */
export async function mapWithConcurrency<TIn, TOut>(
  items: TIn[],
  concurrency: number,
  mapper: (item: TIn) => Promise<TOut>
): Promise<TOut[]> {
  const output: TOut[] = new Array<TOut>(items.length)
  let nextIndex: number = 0

  const worker = async (): Promise<void> => {
    while (true) {
      const currentIndex: number = nextIndex
      nextIndex = nextIndex + 1
      if (currentIndex >= items.length) {
        return
      }
      const value: TOut = await mapper(items[currentIndex])
      output[currentIndex] = value
    }
  }

  const actualConcurrency: number = Math.max(1, Math.min(concurrency, items.length))
  const workers: Promise<void>[] = []
  for (let i: number = 0; i < actualConcurrency; i++) {
    workers.push(worker())
  }
  await Promise.all(workers)
  return output
}

/**
 * 上传单张图片（示例占位函数）：在宿主线程/业务线程里做网络 I/O，并可单独限流。
 */
export async function uploadImage(id: string, data: ArrayBuffer): Promise<UploadResult> {
  const result: UploadResult = {
    id,
    ok: true,
    remoteUrl: ''
  }
  return result
}

/**
 * 批量处理并上传图片：
 * - CPU 阶段：用 TaskPool 并显式限流
 * - 网络阶段：在宿主线程执行并显式限流
 */
export async function batchProcessAndUpload(
  images: ImageItem[],
  cpuConcurrency: number,
  netConcurrency: number
): Promise<UploadResult[]> {
  const processed: ProcessedImage[] = await mapWithConcurrency<ImageItem, ProcessedImage>(
    images,
    cpuConcurrency,
    async (img: ImageItem): Promise<ProcessedImage> => {
      const data: ArrayBuffer = await processImageInTaskPool(img.srcPath)
      const out: ProcessedImage = { id: img.id, data }
      return out
    }
  )

  const uploaded: UploadResult[] = await mapWithConcurrency<ProcessedImage, UploadResult>(
    processed,
    netConcurrency,
    async (img: ProcessedImage): Promise<UploadResult> => {
      const res: UploadResult = await uploadImage(img.id, img.data)
      return res
    }
  )

  return uploaded
}

使用建议（经验，可按设备/业务调优）：

• cpuConcurrency: 2~4（图片压缩/缩放通常 CPU 重）
• netConcurrency: 4~8（看服务端限流与网络质量）

参考文档

• [@ohos.taskpool（启动任务池）](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool)
• 同步任务开发指导 (TaskPool和Worker)