TaskPool——适合一次性任务，扔进去等结果就行。但当你需要长驻后台线程、维护 WebSocket 连接、做持续的数据处理流水线时，TaskPool 的"用完即走"模式就不够了。Worker 才是这种场景的正解——它创建一个持久线程，通过 postMessage/onMessage 双向通信，生命周期由你控制。这篇把 Worker 的创建、通信、销毁完整讲清楚。

Worker vs TaskPool 怎么选

维度	TaskPool	Worker
生命周期	临时，任务完成即销毁	持久，手动创建和销毁
通信	单次传参+返回值	持续双向 postMessage
适合场景	一次性计算、图片处理	长连接、数据流、持续监听
线程数	框架自动管理	开发者手动管理
数据传递	结构化克隆	结构化克隆 + SharedArrayBuffer

决策： 算一次拿结果→TaskPool。持续跑、持续通信→Worker。

Worker 基础

Worker 分两端：宿主线程（主线程）和 Worker 线程。两端的代码在不同文件中。

主线程创建 Worker

import { worker } from '@kit.ArkTS'

let workerInstance: worker.ThreadWorker = new worker.ThreadWorker('../workers/MyWorker.ets')

注意： Worker 脚本路径相对于主线程文件。../workers/MyWorker.ets 表示上层 workers 目录。

Worker 线程脚本

// workers/MyWorker.ets
import { worker, MessageEvents, ThreadWorkerGlobalScope } from '@kit.ArkTS'

const workerPort: ThreadWorkerGlobalScope = worker.workerPort

workerPort.onmessage = (e: MessageEvents) => {
  let data: string = e.data as string
  // 处理数据
  let result: string = `处理完成: ${data}`
  workerPort.postMessage(result)
}

双向通信

主线程 → Worker：postMessage
Worker → 主线程：workerPort.postMessage

interface WorkerMessage {
  type: string
  payload: string
}

@Entry
@Component
struct WorkerBasicDemo {
  @State receivedMsg: string = '等待消息...'
  @State sentMsg: string = ''
  @State isRunning: boolean = false
  private workerInstance: worker.ThreadWorker | null = null

  build() {
    Column({ space: 16 }) {
      Text('Worker 双向通信')
        .fontSize(22)
        .fontWeight(FontWeight.Bold)
        .width('100%')

      Text(`收到: ${this.receivedMsg}`)
        .fontSize(16)
        .padding(12)
        .borderRadius(8)
        .backgroundColor('#E8F5E9')
        .width('100%')

      Row({ space: 8 }) {
        TextInput({ placeholder: '发送给Worker' })
          .layoutWeight(1)
          .onChange((value: string) => { this.sentMsg = value })
        Button('发送')
          .onClick(() => {
            if (this.workerInstance) {
              this.workerInstance.postMessage(this.sentMsg)
            }
          })
      }

      Row({ space: 8 }) {
        Button('创建Worker').onClick(() => this.createWorker())
        Button('销毁Worker').onClick(() => this.destroyWorker())
      }

      Text(this.isRunning ? 'Worker运行中' : 'Worker未创建')
        .fontSize(13)
        .fontColor(this.isRunning ? '#4CAF50' : '#999999')
    }
    .width('100%')
    .padding(20)
  }

  private createWorker(): void {
    this.workerInstance = new worker.ThreadWorker('../workers/MyWorker.ets')
    this.isRunning = true

    this.workerInstance.onmessage = (e: MessageEvents) => {
      this.receivedMsg = e.data as string
    }

    this.workerInstance.onerror = (e: ErrorEvent) => {
      this.receivedMsg = `Worker错误: ${e.message}`
    }

    this.workerInstance.onexit = () => {
      this.isRunning = false
    }
  }

  private destroyWorker(): void {
    if (this.workerInstance) {
      this.workerInstance.terminate()
      this.workerInstance = null
    }
  }
}

关键区别： 主线程用 workerInstance.onmessage 接收，Worker 线程用 workerPort.onmessage 接收。两个 onmessage 方向相反。

Worker 生命周期

Worker 的生命周期完全由开发者控制：创建 → 通信 → 销毁。

事件	触发时机	主线程	Worker线程
onmessage	收到对方消息	workerInstance.onmessage	workerPort.onmessage
onerror	运行出错	workerInstance.onerror	workerPort.onerror
onexit	Worker退出	workerInstance.onexit	workerPort.onexit
onmessageerror	无法序列化的消息	workerInstance.onmessageerror	workerPort.onmessageerror

销毁方式：

• 主线程调用 workerInstance.terminate() ——主动销毁
• Worker 线程调用 workerPort.close() ——自行退出
• 两者效果相同，Worker 的 onexit 都会触发

重计算实战：Fibonacci

主线程算 Fibonacci(n>40) 会卡死 UI，Worker 算则 UI 完全不卡。

// workers/FibWorker.ets
import { worker, MessageEvents, ThreadWorkerGlobalScope } from '@kit.ArkTS'

const workerPort: ThreadWorkerGlobalScope = worker.workerPort

function fibonacci(n: number): number {
  if (n <= 1) return n
  return fibonacci(n - 1) + fibonacci(n - 2)
}

workerPort.onmessage = (e: MessageEvents) => {
  let n: number = e.data as number
  let start: number = Date.now()
  let result: number = fibonacci(n)
  let duration: number = Date.now() - start
  workerPort.postMessage(`fib(${n})=${result}, 耗时${duration}ms`)
}

@Entry
@Component
struct FibWorkerDemo {
  @State resultText: string = '等待计算...'
  @State inputN: string = '40'
  @State isComputing: boolean = false
  private fibWorker: worker.ThreadWorker | null = null

  aboutToAppear(): void {
    this.fibWorker = new worker.ThreadWorker('../workers/FibWorker.ets')
    this.fibWorker.onmessage = (e: MessageEvents) => {
      this.resultText = e.data as string
      this.isComputing = false
    }
  }

  aboutToDisappear(): void {
    if (this.fibWorker) {
      this.fibWorker.terminate()
      this.fibWorker = null
    }
  }

  build() {
    Column({ space: 16 }) {
      Text('Fibonacci Worker 计算')
        .fontSize(22)
        .fontWeight(FontWeight.Bold)
        .width('100%')

      Text('主线程算大数会卡UI，Worker算UI完全不卡')
        .fontSize(13)
        .fontColor('#999999')
        .width('100%')

      Row({ space: 8 }) {
        TextInput({ text: this.inputN, placeholder: '输入n值' })
          .width(100)
          .type(InputType.Number)
          .onChange((value: string) => { this.inputN = value })
        Button('Worker计算')
          .enabled(!this.isComputing)
          .onClick(() => {
            this.isComputing = true
            this.resultText = '计算中...'
            this.fibWorker?.postMessage(parseInt(this.inputN))
          })
      }

      Text(this.resultText)
        .fontSize(16)
        .padding(12)
        .borderRadius(8)
        .backgroundColor(this.isComputing ? '#FFF3E0' : '#E8F5E9')
        .width('100%')

      if (this.isComputing) {
        LoadingProgress().width(40).height(40)
        Text('UI 仍然可以交互（滑动、点击）')
          .fontSize(13)
          .fontColor('#4CAF50')
      }
    }
    .width('100%')
    .padding(20)
  }
}

要点： Worker 计算期间主线程 UI 完全不卡——可以自由滑动、点击、切换页面。计算完成后 onmessage 回调更新结果。

数据流实战：进度回调

Worker 处理多步骤任务时，通过多次 postMessage 报告进度。

// workers/ProgressWorker.ets
import { worker, MessageEvents, ThreadWorkerGlobalScope } from '@kit.ArkTS'

const workerPort: ThreadWorkerGlobalScope = worker.workerPort

workerPort.onmessage = (e: MessageEvents) => {
  let total: number = e.data as number
  let steps: number = 5
  let stepSize: number = Math.floor(total / steps)

  for (let i: number = 1; i <= steps; i++) {
    // 模拟每个步骤的处理
    let processed: number = i * stepSize
    // 报告进度
    workerPort.postMessage(`步骤${i}/${steps}完成，已处理${processed}条`)
  }

  workerPort.postMessage(`全部完成，共处理${total}条数据`)
}

@Entry
@Component
struct ProgressWorkerDemo {
  @State progressList: string[] = []
  @State totalCount: string = '1000'
  @State isProcessing: boolean = false
  private progressWorker: worker.ThreadWorker | null = null

  aboutToAppear(): void {
    this.progressWorker = new worker.ThreadWorker('../workers/ProgressWorker.ets')
    this.progressWorker.onmessage = (e: MessageEvents) => {
      let msg: string = e.data as string
      this.progressList.push(msg)
      if (msg.includes('全部完成')) {
        this.isProcessing = false
      }
    }
  }

  aboutToDisappear(): void {
    this.progressWorker?.terminate()
  }

  build() {
    Column({ space: 16 }) {
      Text('Worker 进度回调')
        .fontSize(22)
        .fontWeight(FontWeight.Bold)
        .width('100%')

      Row({ space: 8 }) {
        TextInput({ text: this.totalCount, placeholder: '数据总量' })
          .width(100)
          .type(InputType.Number)
          .onChange((value: string) => { this.totalCount = value })
        Button('开始处理')
          .enabled(!this.isProcessing)
          .onClick(() => {
            this.progressList = []
            this.isProcessing = true
            this.progressWorker?.postMessage(parseInt(this.totalCount))
          })
      }

      ForEach(this.progressList, (msg: string, index: number) => {
        Text(msg)
          .fontSize(13)
          .fontColor(msg.includes('全部完成') ? '#4CAF50' : '#333333')
          .width('100%')
          .padding(4)
      }, (msg: string, index: number) => `${index}`)
    }
    .width('100%')
    .padding(20)
  }
}

要点： Worker 内可以多次调用 workerPort.postMessage，主线程每次 onmessage 都能收到。适合多步骤任务的进度汇报。

Worker 注意事项

1. Worker 数量有限制——最多创建 8 个 Worker（含主线程），超过会报错
2. Worker 文件不能引用 ArkUI 装饰器——@Component/@State 等在 Worker 中不可用
3. 数据传递用结构化克隆——函数、DOM 节点、@Observed 类实例不能直接传
4. Worker 文件路径——相对于调用者文件，建议放在 workers 目录下
5. 必须在 aboutToDisappear 中销毁——否则内存泄漏

踩坑清单

问题	原因	解决
Worker 创建报错	路径不对或文件不存在	检查相对路径，确认文件存在
Worker 内引用 @State 报错	ArkUI 装饰器不能在 Worker 用	Worker 只做纯逻辑，不碰 UI
postMessage 传 @Observed 对象报错	对象含不可克隆属性	传纯数据对象（interface/Record）
Worker 超过8个	数量限制	用 TaskPool 替代或合并 Worker
onmessage 收不到	通信方向搞反	主线程→workerInstance，Worker→workerPort
terminate 后 postMessage 崩溃	Worker 已销毁	terminate 后置 null，发送前检查
Worker 内 import 报错	导入了含装饰器的文件	Worker 只 import 纯逻辑模块
数据传递慢	结构化克隆拷贝大数据	用 SharedArrayBuffer 零拷贝
Worker onexit 不触发	未正确销毁	用 terminate() 或 close() 主动退出
重复创建 Worker	未检查已有实例	创建前先销毁旧实例