1# @ohos.worker (启动一个Worker) 2 3Worker是与主线程并行的独立线程。创建Worker的线程称之为宿主线程，Worker自身的线程称之为Worker线程。创建Worker传入的url文件在Worker线程中执行，可以处理耗时操作但不可以直接操作UI。 4 5Worker主要作用是为应用程序提供一个多线程的运行环境，可满足应用程序在执行过程中与主线程分离，在后台线程中运行一个脚本操作耗时操作，极大避免类似于计算密集型或高延迟的任务阻塞主线程的运行。由于Worker一旦被创建则不会主动被销毁，若不处于任务状态一直运行，在一定程度上会造成资源的浪费，应及时关闭空闲的Worker。 6 7Worker的上下文对象和主线程的上下文对象是不同的，Worker线程不支持UI操作。 8 9Worker使用过程中的相关注意点请查[Worker注意事项](../../arkts-utils/worker-introduction.md#worker注意事项) 10 11> **说明：**<br/> 12> 本模块首批接口从API version 7 开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 13 14## 导入模块 15 16```ts 17import { worker } from '@kit.ArkTS'; 18``` 19 20 21## 属性 22 23**系统能力：** SystemCapability.Utils.Lang 24 25| 名称 | 类型 | 可读 | 可写 | 说明 | 26| --------------------------------- | ------------------------------------------------------------ | ---- | ---- | ------------------------------------------------------------ | 27| workerPort<sup>9+</sup> | [ThreadWorkerGlobalScope](#threadworkerglobalscope9) | 是 | 是 | worker线程用于与宿主线程通信的对象。**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 28| parentPort<sup>(deprecated)</sup> | [DedicatedWorkerGlobalScope](#dedicatedworkerglobalscopedeprecated) | 是 | 是 | worker线程用于与宿主线程通信的对象。<br/>此属性从API version 7开始支持,从API version 9 开始被废弃。<br/>建议使用workerPort<sup>9+</sup>替代。 | 29 30 31## WorkerOptions 32 33Worker构造函数的选项信息，用于为Worker添加其他信息。 34 35**系统能力：** SystemCapability.Utils.Lang 36 37| 名称 | 类型 | 只读 | 可选 | 说明 | 38| ---- | -------- | ---- | ---- | -------------- | 39| type | 'classic' \| 'module' | 是 | 是 | Worker执行脚本的模式类型，暂不支持module类型，默认值为"classic"。<br/>**原子化服务API：** 从API version 11 开始，该接口支持在原子化服务中使用。 | 40| name | string | 是 | 是 | Worker的名称，默认值为 undefined 。<br/>**原子化服务API：** 从API version 11 开始，该接口支持在原子化服务中使用。| 41| shared | boolean | 是 | 是 | 表示Worker共享功能，此接口暂不支持。 <br/>**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。| 42 43## ThreadWorker<sup>9+</sup> 44 45使用以下方法前，均需先构造ThreadWorker实例，ThreadWorker类继承[WorkerEventTarget](#workereventtarget9)。 46 47### constructor<sup>9+</sup> 48 49constructor(scriptURL: string, options?: WorkerOptions) 50 51ThreadWorker构造函数。 52 53**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 54 55**系统能力：** SystemCapability.Utils.Lang 56 57**参数：** 58 59| 参数名 | 类型 | 必填 | 说明 | 60| --------- | ------------------------------- | ---- | ------------------------------------------------------------ | 61| scriptURL | string | 是 | Worker线程文件的路径。<br/>路径规则详细参考[文件路径注意事项](../../arkts-utils/worker-introduction.md#文件路径注意事项)。 | 62| options | [WorkerOptions](#workeroptions) | 否 | Worker构造的选项。 | 63 64**错误码：** 65 66以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 67 68| 错误码ID | 错误信息 | 69| -------- | -------- | 70| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 71| 10200003 | Worker initialization failed. | 72| 10200007 | The worker file path is invalid. | 73 74**示例：** 75 76此处以在Stage模型中Ability加载Worker文件为例，使用Library加载Worker线程文件的场景参考[文件路径注意事项](../../arkts-utils/worker-introduction.md#文件路径注意事项)。 77 78```ts 79import { worker } from '@kit.ArkTS'; 80 81// 主要说明以下两种场景： 82 83// 场景1： worker文件所在路径："entry/src/main/ets/workers/worker.ets" 84const workerStageModel01 = new worker.ThreadWorker('entry/ets/workers/worker.ets', {name:"first worker in Stage model"}); 85 86// 场景2： worker文件所在路径："phone/src/main/ets/ThreadFile/workers/worker.ets" 87const workerStageModel02 = new worker.ThreadWorker('phone/ets/ThreadFile/workers/worker.ets'); 88``` 89 90 91### postMessage<sup>9+</sup> 92 93postMessage(message: Object, transfer: ArrayBuffer[]): void 94 95宿主线程通过转移对象所有权的方式向Worker线程发送消息。 96 97**系统能力：** SystemCapability.Utils.Lang 98 99**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 100 101**参数：** 102 103| 参数名 | 类型 | 必填 | 说明 | 104| -------- | ------------- | ---- | ------------------------------------------------------------ | 105| message | Object | 是 | 发送至Worker的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 106| transfer | ArrayBuffer[] | 是 | 表示可转移的ArrayBuffer实例对象数组，该数组中对象的所有权会被转移到Worker线程，在宿主线程中将会变为不可用，仅在Worker线程中可用，数组不可传入null。 | 107 108**错误码：** 109 110以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 111 112| 错误码ID | 错误信息 | 113| -------- | ----------------------------------------- | 114| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 115| 10200004 | The Worker instance is not running. | 116| 10200006 | An exception occurred during serialization. | 117 118**示例：** 119 120```ts 121const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 122 123let buffer = new ArrayBuffer(8); 124workerInstance.postMessage(buffer, [buffer]); 125``` 126 127### postMessage<sup>9+</sup> 128 129postMessage(message: Object, options?: PostMessageOptions): void 130 131宿主线程通过转移对象所有权或者拷贝数据的方式向Worker线程发送消息。 132 133**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 134 135**系统能力：** SystemCapability.Utils.Lang 136 137**参数：** 138 139| 参数名 | 类型 | 必填 | 说明 | 140| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 141| message | Object | 是 | 发送至Worker的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 142| options | [PostMessageOptions](#postmessageoptions) | 否 | 当填入该参数时，与传入ArrayBuffer[]的作用一致，该数组中对象的所有权会被转移到Worker线程，在宿主线程中将会变为不可用，仅在Worker线程中可用。<br>若不填入该参数，默认设置为 undefined，通过拷贝数据的方式传输信息到Worker线程。 | 143 144**错误码：** 145 146以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 147 148| 错误码ID | 错误信息 | 149| -------- | ----------------------------------------- | 150| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 151| 10200004 | The Worker instance is not running. | 152| 10200006 | An exception occurred during serialization. | 153 154**示例：** 155 156```ts 157const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 158 159workerInstance.postMessage("hello world"); 160 161let buffer = new ArrayBuffer(8); 162workerInstance.postMessage(buffer, [buffer]); 163``` 164 165 166### postMessageWithSharedSendable<sup>12+</sup> 167 168postMessageWithSharedSendable(message: Object, transfer?: ArrayBuffer[]): void 169 170宿主线程向Worker线程发送消息，消息中的Sendable对象通过引用传递，消息中的非Sendable对象通过序列化传递。 171 172**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 173 174**系统能力：** SystemCapability.Utils.Lang 175 176**参数：** 177 178| 参数名 | 类型 | 必填 | 说明 | 179| --------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 180| message | Object | 是 | 发送至Worker的数据，该数据对象必须是可序列化或可共享，序列化支持类型见[序列化类型说明](#序列化支持类型)，共享支持类型见[Sendable支持的数据类型](../../arkts-utils/sendable-overview.md#sendable支持的数据类型)。 | 181| transfer | ArrayBuffer[] | 否 | 表示可转移的ArrayBuffer实例对象数组，该数组中对象的所有权会被转移到Worker线程，在宿主线程中将会变为不可用，仅在Worker线程中可用，数组不可传入null。默认值为空数组。 | 182 183**错误码：** 184 185以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 186 187| 错误码ID | 错误信息 | 188| -------- | ----------------------------------------- | 189| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 190| 10200004 | The Worker instance is not running. | 191| 10200006 | An exception occurred during serialization. | 192 193**示例：** 194 195<!--code_no_check--> 196```ts 197// index.ets 198// 新建SendableObject实例并通过宿主线程传递至worker线程 199 200import { worker } from '@kit.ArkTS'; 201import { SendableObject } from './sendable' 202 203const workerInstance = new worker.ThreadWorker("entry/ets/workers/Worker.ets"); 204let object: SendableObject = new SendableObject(); 205workerInstance.postMessageWithSharedSendable(object); 206``` 207 208```ts 209// sendable.ets 210// 定义SendableObject 211 212@Sendable 213export class SendableObject { 214 a:number = 45; 215} 216``` 217 218<!--code_no_check--> 219```ts 220// worker文件路径为：entry/src/main/ets/workers/Worker.ets 221// Worker.ets 222// 接收宿主线程传递至worker线程的数据并访问 223 224import { SendableObject } from '../pages/sendable' 225import { worker, ThreadWorkerGlobalScope, MessageEvents, ErrorEvent } from '@kit.ArkTS'; 226 227const workerPort: ThreadWorkerGlobalScope = worker.workerPort; 228workerPort.onmessage = (e: MessageEvents) => { 229 let obj: SendableObject = e.data; 230 console.info("sendable obj is: " + obj.a); 231} 232``` 233 234 235### on<sup>9+</sup> 236 237on(type: string, listener: WorkerEventListener): void 238 239向Worker添加一个事件监听，该接口与[addEventListener<sup>9+</sup>](#addeventlistener9)接口功能一致。 240 241**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 242 243**系统能力：** SystemCapability.Utils.Lang 244 245**参数：** 246 247| 参数名 | 类型 | 必填 | 说明 | 248| -------- | -------------------------------------------- | ---- | ---------------------- | 249| type | string | 是 | 监听的事件类型。 | 250| listener | [WorkerEventListener](#workereventlistener9) | 是 | 回调的事件。 | 251 252**错误码：** 253 254以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 255 256| 错误码ID | 错误信息 | 257| -------- | -------------------------------------------- | 258| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 259| 10200004 | Worker instance is not running. | 260| 10200005 | The invoked API is not supported in workers. | 261 262**示例：** 263 264```ts 265const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 266workerInstance.on("alert", (e)=>{ 267 console.log("alert listener callback"); 268}) 269``` 270 271 272### once<sup>9+</sup> 273 274once(type: string, listener: WorkerEventListener): void 275 276向Worker添加一个事件监听，事件监听只执行一次便自动删除。 277 278**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 279 280**系统能力：** SystemCapability.Utils.Lang 281 282**参数：** 283 284| 参数名 | 类型 | 必填 | 说明 | 285| -------- | -------------------------------------------- | ---- | ---------------------- | 286| type | string | 是 | 监听的事件类型。 | 287| listener | [WorkerEventListener](#workereventlistener9) | 是 | 回调的事件。 | 288 289**错误码：** 290 291以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 292 293| 错误码ID | 错误信息 | 294| -------- | -------------------------------------------- | 295| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 296| 10200004 | Worker instance is not running. | 297| 10200005 | The invoked API is not supported in workers. | 298 299**示例：** 300 301```ts 302const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 303workerInstance.once("alert", (e)=>{ 304 console.log("alert listener callback"); 305}) 306``` 307 308 309### off<sup>9+</sup> 310 311off(type: string, listener?: WorkerEventListener): void 312 313删除类型为type的事件监听，该接口与[removeEventListener<sup>9+</sup>](#removeeventlistener9)接口功能一致。 314 315**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 316 317**系统能力：** SystemCapability.Utils.Lang 318 319**参数：** 320 321| 参数名 | 类型 | 必填 | 说明 | 322| -------- | -------------------------------------------- | ---- | ---------------------------- | 323| type | string | 是 | 需要删除的事件类型。 | 324| listener | [WorkerEventListener](#workereventlistener9) | 否 | 删除监听事件后所执行的回调事件。 | 325 326**错误码：** 327 328以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 329 330| 错误码ID | 错误信息 | 331| -------- | -------------------------------------------- | 332| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 333| 10200004 | Worker instance is not running. | 334| 10200005 | The invoked API is not supported in workers. | 335 336**示例：** 337 338```ts 339const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 340//使用on接口、once接口或addEventListener接口创建“alert”事件，使用off接口删除事件。 341workerInstance.off("alert"); 342``` 343 344### registerGlobalCallObject<sup>11+</sup> 345 346registerGlobalCallObject(instanceName: string, globalCallObject: Object): void 347 348在宿主线程的ThreadWorker实例上注册一个对象，该对象上的方法可以在Worker线程中被调用，详细介绍请参见[callGlobalCallObjectMethod](#callglobalcallobjectmethod11)。 349 350**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 351 352**系统能力：** SystemCapability.Utils.Lang 353 354**参数：** 355 356| 参数名 | 类型 | 必填 | 说明 | 357| -------- | ------------- | ---- | ------------------------------------------------------------ | 358| instanceName | string | 是 | 注册对象时使用的键，调用时可以通过该键值找到相对应的被注册的对象。 | 359| globalCallObject | Object | 是 | 被注册的对象，ThreadWorker实例会持有被注册对象的强引用。 | 360 361**错误码：** 362 363以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 364 365| 错误码ID | 错误信息 | 366| -------- | ----------------------------------------- | 367| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 368| 10200004 | Worker instance is not running. | 369 370**示例：** 371```ts 372const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 373class TestObj { 374 private message : string = "this is a message from TestObj" 375 public getMessage() : string { 376 return this.message; 377 } 378 public getMessageWithInput(str : string) : string { 379 return this.message + " with input: " + str; 380 } 381} 382let registerObj = new TestObj(); 383// 在ThreadWorker实例上注册registerObj 384workerInstance.registerGlobalCallObject("myObj", registerObj); 385workerInstance.postMessage("start worker") 386``` 387 388### unregisterGlobalCallObject<sup>11+</sup> 389 390unregisterGlobalCallObject(instanceName?: string): void 391 392取消在宿主线程ThreadWorker实例上注册的对象，该方法会释放ThreadWorker实例中与该键相匹配对象的强引用，没有匹配对象时不会报错。 393 394**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 395 396**系统能力：** SystemCapability.Utils.Lang 397 398**参数：** 399 400| 参数名 | 类型 | 必填 | 说明 | 401| -------- | ------------- | ---- | ------------------------------------------------------------ | 402| instanceName | string | 否 | 注册对象时使用的键，此参数不填时，会释放ThreadWorker实例中所有已注册的对象。 | 403 404**错误码：** 405 406以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 407 408| 错误码ID | 错误信息 | 409| -------- | ----------------------------------------- | 410| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 411| 10200004 | Worker instance is not running. | 412 413**示例：** 414```ts 415const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 416class TestObj { 417 private message : string = "this is a message from TestObj" 418 public getMessage() : string { 419 return this.message; 420 } 421 public getMessageWithInput(str : string) : string { 422 return this.message + " with input: " + str; 423 } 424} 425let registerObj = new TestObj(); 426workerInstance.registerGlobalCallObject("myObj", registerObj); 427// 取消对象注册 428workerInstance.unregisterGlobalCallObject("myObj"); 429// 取消ThreadWorker实例上的所有对象注册 430//workerInstance.unregisterGlobalCallObject(); 431workerInstance.postMessage("start worker") 432``` 433 434### terminate<sup>9+</sup> 435 436terminate(): void 437 438销毁Worker线程，终止Worker接收消息。 439 440**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 441 442**系统能力：** SystemCapability.Utils.Lang 443 444**错误码：** 445 446以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 447 448| 错误码ID | 错误信息 | 449| -------- | ------------------------------- | 450| 10200004 | The Worker instance is not running. | 451 452**示例：** 453 454```ts 455const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 456workerInstance.terminate(); 457``` 458 459 460### onexit<sup>9+</sup> 461 462onexit?: (code: number) => void 463 464回调函数。表示Worker销毁时被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中code类型为number，异常退出为1，正常退出为0。 465 466**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 467 468**系统能力：** SystemCapability.Utils.Lang 469 470**错误码：** 471 472以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 473 474| 错误码ID | 错误信息 | 475| -------- | -------------------------------------------- | 476| 401 | Parameter error. Possible causes: 1.Incorrect parameter types. | 477| 10200004 | The Worker instance is not running. | 478| 10200005 | The called API is not supported in the worker thread. | 479 480**示例：** 481 482```ts 483const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 484workerInstance.onexit = (code) => { 485 console.log("onexit"); 486} 487 488//onexit被执行两种方式： 489// main thread： 490workerInstance.terminate(); 491 492// worker线程： 493//workerPort.close() 494``` 495 496 497### onerror<sup>9+</sup> 498 499onerror?: (err: ErrorEvent) => void 500 501回调函数。表示Worker在执行过程中发生异常被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中err类型为[ErrorEvent](#errorevent)，表示收到的异常数据。 502 503**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 504 505**系统能力：** SystemCapability.Utils.Lang 506 507**错误码：** 508 509以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 510 511| 错误码ID | 错误信息 | 512| -------- | -------------------------------------------- | 513| 401 | Parameter error. Possible causes: 1.Incorrect parameter types. | 514| 10200004 | The Worker instance is not running. | 515| 10200005 | The called API is not supported in the worker thread. | 516 517**示例：** 518 519```ts 520import { worker, ErrorEvent } from '@kit.ArkTS'; 521 522const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 523workerInstance.onerror = (err: ErrorEvent) => { 524 console.log("onerror" + err.message); 525} 526``` 527 528 529### onmessage<sup>9+</sup> 530 531onmessage?: (event: MessageEvents) => void 532 533回调函数。表示宿主线程接收到来自其创建的Worker通过workerPort.postMessage接口发送的消息时被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中event类型为[MessageEvents](#messageevents9)，表示收到的Worker消息数据。 534 535**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 536 537**系统能力：** SystemCapability.Utils.Lang 538 539**错误码：** 540 541以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 542 543| 错误码ID | 错误信息 | 544| -------- | -------------------------------------------- | 545| 401 | Parameter error. Possible causes: 1.Incorrect parameter types. | 546| 10200004 | The Worker instance is not running. | 547| 10200005 | The called API is not supported in the worker thread. | 548 549**示例：** 550 551```ts 552import { worker, MessageEvents } from '@kit.ArkTS'; 553 554const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 555workerInstance.onmessage = (e: MessageEvents): void => { 556 // e : MessageEvents, 用法如下： 557 // let data = e.data; 558 console.log("onmessage"); 559} 560``` 561 562 563### onmessageerror<sup>9+</sup> 564 565onmessageerror?: (event: MessageEvents) => void 566 567回调函数。表示当Worker对象接收到一条无法被序列化的消息时被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中event类型为[MessageEvents](#messageevents9)，表示收到的Worker消息数据。 568 569**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 570 571**系统能力：** SystemCapability.Utils.Lang 572 573**错误码：** 574 575以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 576 577| 错误码ID | 错误信息 | 578| -------- | -------------------------------------------- | 579| 401 | Parameter error. Possible causes: 1.Incorrect parameter types. | 580| 10200004 | The Worker instance is not running. | 581| 10200005 | The called API is not supported in the worker thread. | 582 583**示例：** 584 585```ts 586import { worker, MessageEvents } from '@kit.ArkTS'; 587 588const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 589workerInstance.onmessageerror = (err: MessageEvents) => { 590 console.log("onmessageerror"); 591} 592``` 593 594### addEventListener<sup>9+</sup> 595 596addEventListener(type: string, listener: WorkerEventListener): void 597 598向Worker添加一个事件监听，该接口与[on<sup>9+</sup>](#on9)接口功能一致。 599 600**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 601 602**系统能力：** SystemCapability.Utils.Lang 603 604**参数：** 605 606| 参数名 | 类型 | 必填 | 说明 | 607| -------- | -------------------------------------------- | ---- | ---------------- | 608| type | string | 是 | 监听的事件类型。 | 609| listener | [WorkerEventListener](#workereventlistener9) | 是 | 回调的事件。 | 610 611**错误码：** 612 613以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 614 615| 错误码ID | 错误信息 | 616| -------- | -------------------------------------------- | 617| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 618| 10200004 | Worker instance is not running. | 619| 10200005 | The invoked API is not supported in workers. | 620 621**示例：** 622 623```ts 624const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 625workerInstance.addEventListener("alert", (e)=>{ 626 console.log("alert listener callback"); 627}) 628``` 629 630 631### removeEventListener<sup>9+</sup> 632 633removeEventListener(type: string, callback?: WorkerEventListener): void 634 635删除Worker的事件监听，该接口与[off<sup>9+</sup>](#off9)接口功能一致。 636 637**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 638 639**系统能力：** SystemCapability.Utils.Lang 640 641**参数：** 642 643| 参数名 | 类型 | 必填 | 说明 | 644| -------- | -------------------------------------------- | ---- | ---------------------------- | 645| type | string | 是 | 需要删除的监听事件类型。 | 646| callback | [WorkerEventListener](#workereventlistener9) | 否 | 删除监听事件后所执行的回调事件。 | 647 648**错误码：** 649 650以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 651 652| 错误码ID | 错误信息 | 653| -------- | ------------------------------- | 654| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 655| 10200004 | Worker instance is not running. | 656 657**示例：** 658 659```ts 660const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 661workerInstance.addEventListener("alert", (e)=>{ 662 console.log("alert listener callback"); 663}) 664workerInstance.removeEventListener("alert"); 665``` 666 667 668### dispatchEvent<sup>9+</sup> 669 670dispatchEvent(event: Event): boolean 671 672分发定义在Worker的事件。 673 674**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 675 676**系统能力：** SystemCapability.Utils.Lang 677 678**参数：** 679 680| 参数名 | 类型 | 必填 | 说明 | 681| ------ | --------------- | ---- | ---------------- | 682| event | [Event](#event) | 是 | 需要分发的事件。 | 683 684**返回值：** 685 686| 类型 | 说明 | 687| ------- | ------------------------------- | 688| boolean | 分发的结果，true表示分发成功，false表示分发失败。 | 689 690**错误码：** 691 692以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 693 694| 错误码ID | 错误信息 | 695| -------- | ------------------------------- | 696| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 697| 10200004 | Worker instance is not running. | 698 699**示例：** 700 701```ts 702const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 703 704workerInstance.dispatchEvent({type:"eventType", timeStamp:0}); //timeStamp暂未支持。 705``` 706 707分发事件（dispatchEvent）可与监听接口（on、once、addEventListener）搭配使用，示例如下： 708 709```ts 710import { worker, MessageEvents } from '@kit.ArkTS'; 711 712const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 713 714//用法一: 715workerInstance.on("alert_on", (e)=>{ 716 console.log("alert listener callback"); 717}) 718workerInstance.once("alert_once", (e)=>{ 719 console.log("alert listener callback"); 720}) 721workerInstance.addEventListener("alert_add", (e)=>{ 722 console.log("alert listener callback"); 723}) 724 725//once接口创建的事件执行一次便会删除。 726workerInstance.dispatchEvent({type:"alert_once", timeStamp:0});//timeStamp暂未支持。 727//on接口创建的事件可以一直被分发，不能主动删除。 728workerInstance.dispatchEvent({type:"alert_on", timeStamp:0}); 729workerInstance.dispatchEvent({type:"alert_on", timeStamp:0}); 730//addEventListener接口创建的事件可以一直被分发，不能主动删除。 731workerInstance.dispatchEvent({type:"alert_add", timeStamp:0}); 732workerInstance.dispatchEvent({type:"alert_add", timeStamp:0}); 733 734//用法二: 735//event类型的type支持自定义，同时存在"message"/"messageerror"/"error"特殊类型，如下所示 736//当type = "message"，onmessage接口定义的方法同时会执行。 737//当type = "messageerror"，onmessageerror接口定义的方法同时会执行。 738//当type = "error"，onerror接口定义的方法同时会执行。 739//若调用removeEventListener接口或者off接口取消事件时，能且只能取消使用addEventListener/on/once创建的事件。 740 741workerInstance.addEventListener("message", (e)=>{ 742 console.log("message listener callback"); 743}) 744workerInstance.onmessage = (e: MessageEvents): void => { 745 console.log("onmessage : message listener callback"); 746} 747//调用dispatchEvent分发“message”事件，addEventListener和onmessage中定义的方法都会被执行。 748workerInstance.dispatchEvent({type:"message", timeStamp:0}); 749``` 750 751 752### removeAllListener<sup>9+</sup> 753 754removeAllListener(): void 755 756删除Worker所有的事件监听。 757 758**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 759 760**系统能力：** SystemCapability.Utils.Lang 761 762**错误码：** 763 764以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 765 766| 错误码ID | 错误信息 | 767| -------- | ------------------------------- | 768| 10200004 | Worker instance is not running. | 769 770**示例：** 771 772```ts 773const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 774workerInstance.addEventListener("alert", (e)=>{ 775 console.log("alert listener callback"); 776}) 777workerInstance.removeAllListener(); 778``` 779 780## WorkerEventTarget<sup>9+</sup> 781 782处理Worker监听事件。 783 784### addEventListener<sup>9+</sup> 785 786addEventListener(type: string, listener: WorkerEventListener): void 787 788向Worker添加一个事件监听，该接口与[on<sup>9+</sup>](#on9)接口功能一致。 789 790**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 791 792**系统能力：** SystemCapability.Utils.Lang 793 794**参数：** 795 796| 参数名 | 类型 | 必填 | 说明 | 797| -------- | -------------------------------------------- | ---- | ---------------- | 798| type | string | 是 | 监听的事件类型。 | 799| listener | [WorkerEventListener](#workereventlistener9) | 是 | 回调的事件。 | 800 801**错误码：** 802 803以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 804 805| 错误码ID | 错误信息 | 806| -------- | -------------------------------------------- | 807| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 808| 10200004 | The Worker instance is not running. | 809| 10200005 | The called API is not supported in the worker thread. | 810 811**示例：** 812 813```ts 814const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 815workerInstance.addEventListener("alert", (e)=>{ 816 console.log("alert listener callback"); 817}) 818``` 819 820 821### removeEventListener<sup>9+</sup> 822 823removeEventListener(type: string, callback?: WorkerEventListener): void 824 825删除Worker的事件监听，该接口与[off<sup>9+</sup>](#off9)接口功能一致。 826 827**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 828 829**系统能力：** SystemCapability.Utils.Lang 830 831**参数：** 832 833| 参数名 | 类型 | 必填 | 说明 | 834| -------- | -------------------------------------------- | ---- | ---------------------------- | 835| type | string | 是 | 需要删除的监听事件类型。 | 836| callback | [WorkerEventListener](#workereventlistener9) | 否 | 删除监听事件后所执行的回调事件。 | 837 838**错误码：** 839 840以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 841 842| 错误码ID | 错误信息 | 843| -------- | ------------------------------- | 844| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 845| 10200004 | The Worker instance is not running. | 846 847**示例：** 848 849```ts 850const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 851workerInstance.addEventListener("alert", (e)=>{ 852 console.log("alert listener callback"); 853}) 854workerInstance.removeEventListener("alert"); 855``` 856 857 858### dispatchEvent<sup>9+</sup> 859 860dispatchEvent(event: Event): boolean 861 862分发定义在Worker的事件。 863 864**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 865 866**系统能力：** SystemCapability.Utils.Lang 867 868**参数：** 869 870| 参数名 | 类型 | 必填 | 说明 | 871| ------ | --------------- | ---- | ---------------- | 872| event | [Event](#event) | 是 | 需要分发的事件。 | 873 874**返回值：** 875 876| 类型 | 说明 | 877| ------- | ------------------------------- | 878| boolean | 分发的结果，false表示分发失败。 | 879 880**错误码：** 881 882以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 883 884| 错误码ID | 错误信息 | 885| -------- | ------------------------------- | 886| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 887| 10200004 | The Worker instance is not running. | 888 889**示例：** 890 891```ts 892const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 893 894workerInstance.dispatchEvent({type:"eventType", timeStamp:0}); //timeStamp暂未支持。 895``` 896 897分发事件（dispatchEvent）可与监听接口（on、once、addEventListener）搭配使用，示例如下： 898 899```ts 900import { worker, MessageEvents } from '@kit.ArkTS'; 901 902const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 903 904//用法一: 905workerInstance.on("alert_on", (e)=>{ 906 console.log("alert listener callback"); 907}) 908workerInstance.once("alert_once", (e)=>{ 909 console.log("alert listener callback"); 910}) 911workerInstance.addEventListener("alert_add", (e)=>{ 912 console.log("alert listener callback"); 913}) 914 915//once接口创建的事件执行一次便会删除。 916workerInstance.dispatchEvent({type:"alert_once", timeStamp:0});//timeStamp暂未支持。 917//on接口创建的事件可以一直被分发，不能主动删除。 918workerInstance.dispatchEvent({type:"alert_on", timeStamp:0}); 919workerInstance.dispatchEvent({type:"alert_on", timeStamp:0}); 920//addEventListener接口创建的事件可以一直被分发，不能主动删除。 921workerInstance.dispatchEvent({type:"alert_add", timeStamp:0}); 922workerInstance.dispatchEvent({type:"alert_add", timeStamp:0}); 923 924//用法二: 925//event类型的type支持自定义，同时存在"message"/"messageerror"/"error"特殊类型，如下所示 926//当type = "message"，onmessage接口定义的方法同时会执行。 927//当type = "messageerror"，onmessageerror接口定义的方法同时会执行。 928//当type = "error"，onerror接口定义的方法同时会执行。 929//若调用removeEventListener接口或者off接口取消事件时，能且只能取消使用addEventListener/on/once创建的事件。 930 931workerInstance.addEventListener("message", (e)=>{ 932 console.log("message listener callback"); 933}) 934workerInstance.onmessage = (e: MessageEvents): void => { 935 console.log("onmessage : message listener callback"); 936} 937//调用dispatchEvent分发“message”事件，addEventListener和onmessage中定义的方法都会被执行。 938workerInstance.dispatchEvent({type:"message", timeStamp:0}); 939``` 940 941 942### removeAllListener<sup>9+</sup> 943 944removeAllListener(): void 945 946删除Worker所有的事件监听。 947 948**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 949 950**系统能力：** SystemCapability.Utils.Lang 951 952**错误码：** 953 954以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 955 956| 错误码ID | 错误信息 | 957| -------- | ------------------------------- | 958| 10200004 | The Worker instance is not running. | 959 960**示例：** 961 962```ts 963const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 964workerInstance.addEventListener("alert", (e)=>{ 965 console.log("alert listener callback"); 966}) 967workerInstance.removeAllListener(); 968``` 969 970 971## ThreadWorkerGlobalScope<sup>9+</sup> 972 973Worker线程用于与宿主线程通信的类，通过postMessage接口发送消息给宿主线程、close接口销毁Worker线程。ThreadWorkerGlobalScope类继承[GlobalScope<sup>9+</sup>](#globalscope9)。 974 975### postMessage<sup>9+</sup> 976 977postMessage(messageObject: Object, transfer: ArrayBuffer[]): void; 978 979Worker线程通过转移对象所有权的方式向宿主线程发送消息。 980 981**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 982 983**系统能力：** SystemCapability.Utils.Lang 984 985**参数：** 986 987| 参数名 | 类型 | 必填 | 说明 | 988| -------- | ------------- | ---- | ------------------------------------------------------------ | 989| messageObject | Object | 是 | 发送至宿主线程的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 990| transfer | ArrayBuffer[] | 是 | 表示可转移的ArrayBuffer实例对象数组，该数组中对象的所有权会被转移到宿主线程，在Worker线程中将会变为不可用，仅在宿主线程中可用，数组不可传入null。 | 991 992**错误码：** 993 994以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 995 996| 错误码ID | 错误信息 | 997| -------- | ----------------------------------------- | 998| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 999| 10200004 | The Worker instance is not running. | 1000| 10200006 | An exception occurred during serialization. | 1001 1002**示例：** 1003 1004```ts 1005// main thread 1006import { worker, MessageEvents } from '@kit.ArkTS'; 1007 1008const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 1009workerInstance.postMessage("hello world"); 1010workerInstance.onmessage = (e: MessageEvents): void => { 1011 console.log("receive data from worker.ets"); 1012} 1013``` 1014 1015```ts 1016// worker.ets 1017import { worker, MessageEvents } from '@kit.ArkTS'; 1018 1019const workerPort = worker.workerPort; 1020workerPort.onmessage = (e: MessageEvents): void => { 1021 let buffer = new ArrayBuffer(8); 1022 workerPort.postMessage(buffer, [buffer]); 1023} 1024``` 1025 1026### postMessage<sup>9+</sup> 1027 1028postMessage(messageObject: Object, options?: PostMessageOptions): void 1029 1030Worker线程通过转移对象所有权或者拷贝数据的方式向宿主线程发送消息。 1031 1032**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1033 1034**系统能力：** SystemCapability.Utils.Lang 1035 1036**参数：** 1037 1038| 参数名 | 类型 | 必填 | 说明 | 1039| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 1040| messageObject | Object | 是 | 发送至宿主线程的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 1041| options | [PostMessageOptions](#postmessageoptions) | 否 | 当填入该参数时，与传入ArrayBuffer[]的作用一致，该数组中对象的所有权会被转移到宿主线程，在Worker线程中将会变为不可用，仅在宿主线程中可用。<br/>若不填入该参数，默认设置为 undefined，通过拷贝数据的方式传输信息到宿主线程。 | 1042 1043**错误码：** 1044 1045以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1046 1047| 错误码ID | 错误信息 | 1048| -------- | ----------------------------------------- | 1049| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1050| 10200004 | The Worker instance is not running. | 1051| 10200006 | An exception occurred during serialization. | 1052 1053**示例：** 1054 1055```ts 1056// main thread 1057import { worker, MessageEvents } from '@kit.ArkTS'; 1058 1059const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 1060workerInstance.postMessage("hello world"); 1061workerInstance.onmessage = (e: MessageEvents): void => { 1062 console.log("receive data from worker.ets"); 1063} 1064``` 1065 1066```ts 1067// worker.ets 1068import { worker, MessageEvents } from '@kit.ArkTS'; 1069 1070const workerPort = worker.workerPort; 1071workerPort.onmessage = (e: MessageEvents): void => { 1072 workerPort.postMessage("receive data from main thread"); 1073} 1074``` 1075 1076 1077### postMessageWithSharedSendable<sup>12+</sup> 1078 1079postMessageWithSharedSendable(message: Object, transfer?: ArrayBuffer[]): void 1080 1081Worker线程向宿主线程发送消息，消息中的Sendable对象通过引用传递，消息中的非Sendable对象通过序列化传递。 1082 1083**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 1084 1085**系统能力：** SystemCapability.Utils.Lang 1086 1087**参数：** 1088 1089| 参数名 | 类型 | 必填 | 说明 | 1090| --------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 1091| message | Object | 是 | 发送至宿主线程的数据，该数据对象必须是可序列化或可共享，序列化支持类型见[序列化类型说明](#序列化支持类型)，共享支持类型见[Sendable支持的数据类型](../../arkts-utils/sendable-overview.md#sendable支持的数据类型)。 | 1092| transfer | ArrayBuffer[] | 否 | 表示可转移的ArrayBuffer实例对象数组，该数组中对象的所有权会被转移到宿主线程，在Worker线程中将会变为不可用，仅在宿主线程中可用，数组不可传入null。默认值为空数组。 | 1093 1094**错误码：** 1095 1096以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1097 1098| 错误码ID | 错误信息 | 1099| -------- | ----------------------------------------- | 1100| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1101| 10200004 | The Worker instance is not running. | 1102| 10200006 | An exception occurred during serialization. | 1103 1104**示例：** 1105 1106<!--code_no_check--> 1107```ts 1108// worker文件路径为：entry/src/main/ets/workers/Worker.ets 1109// Worker.ets 1110// 新建SendableObject实例并通过worker线程传递至宿主线程 1111 1112import { SendableObject } from '../pages/sendable' 1113import { worker, ThreadWorkerGlobalScope, MessageEvents, ErrorEvent } from '@kit.ArkTS'; 1114 1115const workerPort: ThreadWorkerGlobalScope = worker.workerPort; 1116workerPort.onmessage = (e: MessageEvents) => { 1117 let object: SendableObject = new SendableObject(); 1118 workerPort.postMessageWithSharedSendable(object); 1119} 1120``` 1121 1122```ts 1123// sendable.ets 1124// 定义SendableObject 1125 1126@Sendable 1127export class SendableObject { 1128 a:number = 45; 1129} 1130``` 1131 1132<!--code_no_check--> 1133```ts 1134// Index.ets 1135// 接收worker线程传递至宿主线程的数据并访问其属性 1136 1137import { worker, MessageEvents } from '@kit.ArkTS'; 1138import { SendableObject } from './sendable' 1139 1140const workerInstance = new worker.ThreadWorker("entry/ets/workers/Worker.ets"); 1141workerInstance.postMessage(1); 1142workerInstance.onmessage = (e: MessageEvents) => { 1143 let obj: SendableObject = e.data; 1144 console.info("sendable index obj is: " + obj.a); 1145} 1146``` 1147 1148 1149### callGlobalCallObjectMethod<sup>11+</sup> 1150 1151callGlobalCallObjectMethod(instanceName: string, methodName: string, timeout: number, ...args: Object[]): Object 1152 1153Worker线程调用注册在宿主线程上某个对象的指定方法，调用对于Worker线程是同步的，对于宿主线程是异步的，返回值通过序列化传递。 1154 1155**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1156 1157**系统能力：** SystemCapability.Utils.Lang 1158 1159**参数：** 1160 1161| 参数名 | 类型 | 必填 | 说明 | 1162| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 1163| instanceName | string | 是 | 注册对象时使用的键，用于在宿主线程查找对象。 | 1164| methodName | string | 是 | 在已注册对象上调用的方法名，注意该方法不能为使用async或generator修饰的方法，或底层使用了异步机制等异步返回结果的方法，否则会抛出异常。 | 1165| timeout | number | 是 | 本次同步调用的等待时间单位为ms，取整数，取值范围为[1-5000]ms。也可取特殊值0，此时表示本次调用等待时间为5000ms。 | 1166| args | Object[] | 否 | 注册对象上所调用方法的参数数组。 | 1167 1168**返回值：** 1169 1170| 类型 | 说明 | 1171| ------------------------------------- | ------------------------------- | 1172| Object | 返回值为调用方法在宿主线程的返回值，该返回值必须是可序列化的，具体可见序列化支持类型。| 1173 1174**错误码：** 1175 1176以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1177 1178| 错误码ID | 错误信息 | 1179| -------- | ----------------------------------------- | 1180| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1181| 10200004 | Worker instance is not running. | 1182| 10200006 | An exception occurred during serialization. | 1183| 10200019 | The globalCallObject is not registered. | 1184| 10200020 | The method to be called is not callable or is an async method or a generator. | 1185| 10200021 | The global call exceeds the timeout. | 1186 1187**示例：** 1188```ts 1189// worker.ets 1190import { worker, MessageEvents } from '@kit.ArkTS'; 1191 1192const workerPort = worker.workerPort; 1193workerPort.onmessage = (e: MessageEvents): void => { 1194 try { 1195 // 调用方法无入参 1196 let res : string = workerPort.callGlobalCallObjectMethod("myObj", "getMessage", 0) as string; 1197 console.info("worker:", res) // worker: this is a message from TestObj 1198 } catch (error) { 1199 // 异常处理 1200 console.error("worker: error code is " + error.code + " error message is " + error.message); 1201 } 1202 try { 1203 // 调用方法有入参 1204 let res : string = workerPort.callGlobalCallObjectMethod("myObj", "getMessageWithInput", 0, "hello there!") as string; 1205 console.info("worker:", res) //worker: this is a message from TestObj with input: hello there! 1206 } catch (error) { 1207 // 异常处理 1208 console.error("worker: error code is " + error.code + " error message is " + error.message); 1209 } 1210} 1211``` 1212 1213### close<sup>9+</sup> 1214 1215close(): void 1216 1217销毁Worker线程，终止Worker接收消息。 1218 1219**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1220 1221**系统能力：** SystemCapability.Utils.Lang 1222 1223**错误码：** 1224 1225以下错误码的详细介绍请参见[语言基础类库错误码](errorcode-utils.md)。 1226 1227| 错误码ID | 错误信息 | 1228| -------- | ------------------------------- | 1229| 10200004 | The Worker instance is not running. | 1230 1231**示例：** 1232 1233```ts 1234// main thread 1235import { worker } from '@kit.ArkTS'; 1236 1237const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 1238``` 1239 1240```ts 1241// worker.ets 1242import { worker, MessageEvents } from '@kit.ArkTS'; 1243 1244const workerPort = worker.workerPort; 1245workerPort.onmessage = (e: MessageEvents): void => { 1246 workerPort.close() 1247} 1248``` 1249 1250 1251### onmessage<sup>9+</sup> 1252 1253onmessage?: (this: ThreadWorkerGlobalScope, ev: MessageEvents) => void 1254 1255回调函数。ThreadWorkerGlobalScope的onmessage属性表示Worker线程收到来自其宿主线程通过postMessage接口发送的消息时被调用的事件处理程序，处理程序在Worker线程中执行。其中this指调用者对象本身[ThreadWorkerGlobalScope](#threadworkerglobalscope9)，ev类型为[MessageEvents](#messageevents9)，表示收到的Worker消息数据。 1256 1257**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1258 1259**系统能力：** SystemCapability.Utils.Lang 1260 1261**错误码：** 1262 1263以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1264 1265| 错误码ID | 错误信息 | 1266| -------- | -------------------------------------------- | 1267| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 1268| 10200004 | The Worker instance is not running. | 1269| 10200005 | The called API is not supported in the worker thread. | 1270 1271**示例：** 1272 1273```ts 1274// main thread 1275import { worker } from '@kit.ArkTS'; 1276 1277const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 1278workerInstance.postMessage("hello world"); 1279``` 1280 1281```ts 1282// worker.ets 1283import { worker, MessageEvents } from '@kit.ArkTS'; 1284 1285const workerPort = worker.workerPort; 1286workerPort.onmessage = (e: MessageEvents): void => { 1287 console.log("receive main thread message"); 1288} 1289``` 1290 1291 1292### onmessageerror<sup>9+</sup> 1293 1294onmessageerror?: (this: ThreadWorkerGlobalScope, ev: MessageEvents) => void 1295 1296回调函数。ThreadWorkerGlobalScope的onmessageerror属性表示当Worker对象接收到一条无法被反序列化的消息时被调用的事件处理程序，处理程序在Worker线程中执行。其中this指调用者对象本身[ThreadWorkerGlobalScope](#threadworkerglobalscope9)，ev类型为[MessageEvents](#messageevents9)，表示收到的Worker消息数据。 1297 1298**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1299 1300**系统能力：** SystemCapability.Utils.Lang 1301 1302**错误码：** 1303 1304以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1305 1306| 错误码ID | 错误信息 | 1307| -------- | -------------------------------------------- | 1308| 401 | Parameter error. Possible causes: 1. Incorrect parameter types. | 1309| 10200004 | The Worker instance is not running. | 1310| 10200005 | The called API is not supported in the worker thread. | 1311 1312**示例：** 1313 1314```ts 1315// main thread 1316import { worker } from '@kit.ArkTS'; 1317 1318const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 1319``` 1320 1321```ts 1322// worker.ets 1323import { worker, MessageEvents } from '@kit.ArkTS'; 1324 1325const workerPort = worker.workerPort; 1326workerPort.onmessageerror = (err: MessageEvents) => { 1327 console.log("worker.ets onmessageerror"); 1328} 1329``` 1330 1331 1332## WorkerEventListener<sup>9+</sup> 1333 1334事件监听类。 1335 1336### (event: Event)<sup>9+</sup> 1337 1338(event: Event): void | Promise<void> 1339 1340**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1341 1342**系统能力：** SystemCapability.Utils.Lang 1343 1344**参数：** 1345 1346| 参数名 | 类型 | 必填 | 说明 | 1347| ------ | --------------- | ---- | -------------- | 1348| event | [Event](#event) | 是 | 回调的事件类。 | 1349 1350**返回值：** 1351 1352| 类型 | 说明 | 1353| ------------------------------------- | ------------------------------- | 1354| void \| Promise<void> | 无返回值或者以Promise形式返回。 | 1355 1356**错误码：** 1357 1358以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1359 1360| 错误码ID | 错误信息 | 1361| -------- | -------------------------------------------- | 1362| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1363| 10200004 | Worker instance is not running. | 1364| 10200005 | The invoked API is not supported in workers. | 1365 1366**示例：** 1367 1368```ts 1369const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets"); 1370workerInstance.addEventListener("alert", (e)=>{ 1371 console.log("alert listener callback"); 1372}) 1373``` 1374 1375 1376## GlobalScope<sup>9+</sup> 1377 1378Worker线程自身的运行环境，GlobalScope类继承[WorkerEventTarget](#workereventtarget9)。 1379 1380### 属性 1381 1382**原子化服务API：** 从API version 11 开始，该接口支持在原子化服务中使用。 1383 1384**系统能力：** SystemCapability.Utils.Lang 1385 1386| 名称 | 类型 | 可读 | 可写 | 说明 | 1387| ---- | ------------------------------------------------------------ | ---- | ---- | ------------------------------------- | 1388| name | string | 是 | 否 | Worker的名字，new Worker时指定。 | 1389| self | [GlobalScope](#globalscope9) & typeof globalThis | 是 | 否 | GlobalScope本身。 | 1390 1391 1392### onerror<sup>9+</sup> 1393 1394onerror?: (ev: ErrorEvent) => void 1395 1396回调函数。GlobalScope的onerror属性表示Worker在执行过程中发生异常被调用的事件处理程序，处理程序在Worker线程中执行。其中回调函数中ev类型为[ErrorEvent](#errorevent)，表示收到的异常数据。 1397 1398**原子化服务API：** 从API version 11 开始，该接口支持在原子化服务中使用。 1399 1400**系统能力：** SystemCapability.Utils.Lang 1401 1402**示例：** 1403 1404```ts 1405// main thread 1406import { worker } from '@kit.ArkTS'; 1407 1408const workerInstance = new worker.ThreadWorker("entry/ets/workers/worker.ets") 1409``` 1410 1411```ts 1412// worker.ets 1413import { worker, ErrorEvent } from '@kit.ArkTS'; 1414 1415const workerPort = worker.workerPort 1416workerPort.onerror = (err: ErrorEvent) => { 1417 console.log("worker.ets onerror" + err.message) 1418} 1419``` 1420 1421## MessageEvents<sup>9+</sup> 1422 1423消息类，持有Worker线程间传递的数据。 1424 1425**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1426 1427**系统能力：** SystemCapability.Utils.Lang 1428 1429| 名称 | 类型 | 可读 | 可写 | 说明 | 1430| ---- | ---- | ---- | ---- | ------------------ | 1431| data | any | 是 | 否 | 线程间传递的数据。 | 1432 1433## Worker<sup>(deprecated)</sup> 1434 1435使用以下方法前，均需先构造Worker实例，Worker类继承[EventTarget](#eventtargetdeprecated)。 1436 1437> **说明：**<br/> 1438> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker<sup>9+</sup>](#threadworker9)替代。 1439 1440### constructor<sup>(deprecated)</sup> 1441 1442constructor(scriptURL: string, options?: WorkerOptions) 1443 1444Worker构造函数。 1445 1446> **说明：**<br/> 1447> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.constructor<sup>9+</sup>](#constructor9)替代。 1448 1449**系统能力：** SystemCapability.Utils.Lang 1450 1451**参数：** 1452 1453| 参数名 | 类型 | 必填 | 说明 | 1454| --------- | ------------------------------- | ---- | ------------------------------------------------------------ | 1455| scriptURL | string | 是 | Worker线程文件的路径，路径规则详细参考[文件路径注意事项](../../arkts-utils/worker-introduction.md#文件路径注意事项)。 | 1456| options | [WorkerOptions](#workeroptions) | 否 | Worker构造的选项。 | 1457 1458**示例：** 1459 1460此处以在Stage模型中Ability加载Worker文件为例，使用Library加载Worker线程文件的场景参考[文件路径注意事项](../../arkts-utils/worker-introduction.md#文件路径注意事项)。 1461 1462 1463```ts 1464import { worker } from '@kit.ArkTS'; 1465 1466// 主要说明以下两种场景： 1467 1468// 场景1： worker文件所在路径："entry/src/main/ets/workers/worker.ets" 1469const workerStageModel01 = new worker.ThreadWorker('entry/ets/workers/worker.ets', {name:"first worker in Stage model"}); 1470 1471// 场景2： worker文件所在路径："phone/src/main/ets/ThreadFile/workers/worker.ets" 1472const workerStageModel02 = new worker.ThreadWorker('phone/ets/ThreadFile/workers/worker.ets'); 1473``` 1474 1475### postMessage<sup>(deprecated)</sup> 1476 1477postMessage(message: Object, transfer: ArrayBuffer[]): void 1478 1479宿主线程通过转移对象所有权的方式向Worker线程发送消息。 1480 1481> **说明：**<br/> 1482> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.postMessage<sup>9+</sup>](#postmessage9)替代。 1483 1484**系统能力：** SystemCapability.Utils.Lang 1485 1486**参数：** 1487 1488| 参数名 | 类型 | 必填 | 说明 | 1489| -------- | ------------- | ---- | ------------------------------------------------------------ | 1490| message | Object | 是 | 发送至Worker的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 1491| transfer | ArrayBuffer[] | 是 | 表示可转移的ArrayBuffer实例对象数组，该数组中对象的所有权会被转移到Worker线程，在宿主线程中将会变为不可用，仅在Worker线程中可用，数组不可传入null。 | 1492 1493**示例：** 1494 1495```ts 1496const workerInstance = new worker.Worker("workers/worker.ets"); 1497 1498let buffer = new ArrayBuffer(8); 1499workerInstance.postMessage(buffer, [buffer]); 1500``` 1501 1502### postMessage<sup>(deprecated)</sup> 1503 1504postMessage(message: Object, options?: PostMessageOptions): void 1505 1506宿主线程通过转移对象所有权或者拷贝数据的方式向Worker线程发送消息。 1507 1508> **说明：**<br/> 1509> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.postMessage<sup>9+</sup>](#postmessage9-1)替代。 1510 1511**系统能力：** SystemCapability.Utils.Lang 1512 1513**参数：** 1514 1515| 参数名 | 类型 | 必填 | 说明 | 1516| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 1517| message | Object | 是 | 发送至Worker的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 1518| options | [PostMessageOptions](#postmessageoptions) | 否 | 当填入该参数时，与传入ArrayBuffer[]的作用一致，该数组中对象的所有权会被转移到Worker线程，在宿主线程中将会变为不可用，仅在Worker线程中可用。<br/>若不填入该参数，默认设置为 undefined，通过拷贝数据的方式传输信息到Worker线程。 | 1519 1520**示例：** 1521 1522```ts 1523const workerInstance = new worker.Worker("workers/worker.ets"); 1524 1525workerInstance.postMessage("hello world"); 1526 1527let buffer = new ArrayBuffer(8); 1528workerInstance.postMessage(buffer, [buffer]); 1529``` 1530 1531 1532### on<sup>(deprecated)</sup> 1533 1534on(type: string, listener: EventListener): void 1535 1536向Worker添加一个事件监听，该接口与[addEventListener<sup>(deprecated)</sup>](#addeventlistenerdeprecated)接口功能一致。 1537 1538> **说明：**<br/> 1539> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.on<sup>9+</sup>](#on9)替代。 1540 1541**系统能力：** SystemCapability.Utils.Lang 1542 1543**参数：** 1544 1545| 参数名 | 类型 | 必填 | 说明 | 1546| -------- | ----------------------------------------- | ---- | ---------------- | 1547| type | string | 是 | 监听的事件类型。 | 1548| listener | [EventListener](#eventlistenerdeprecated) | 是 | 回调事件。 | 1549 1550**示例：** 1551 1552```ts 1553const workerInstance = new worker.Worker("workers/worker.ets"); 1554workerInstance.on("alert", (e)=>{ 1555 console.log("alert listener callback"); 1556}) 1557``` 1558 1559 1560### once<sup>(deprecated)</sup> 1561 1562once(type: string, listener: EventListener): void 1563 1564向Worker添加一个事件监听，事件监听只执行一次便自动删除。 1565 1566> **说明：**<br/> 1567> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.once<sup>9+</sup>](#once9)替代。 1568 1569**系统能力：** SystemCapability.Utils.Lang 1570 1571**参数：** 1572 1573| 参数名 | 类型 | 必填 | 说明 | 1574| -------- | ----------------------------------------- | ---- | ---------------- | 1575| type | string | 是 | 监听的事件类型。 | 1576| listener | [EventListener](#eventlistenerdeprecated) | 是 | 回调事件。 | 1577 1578**示例：** 1579 1580```ts 1581const workerInstance = new worker.Worker("workers/worker.ets"); 1582workerInstance.once("alert", (e)=>{ 1583 console.log("alert listener callback"); 1584}) 1585``` 1586 1587 1588### off<sup>(deprecated)</sup> 1589 1590off(type: string, listener?: EventListener): void 1591 1592删除类型为type的事件监听，该接口与[removeEventListener<sup>(deprecated)</sup>](#removeeventlistenerdeprecated)接口功能一致。 1593 1594> **说明：**<br/> 1595> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.off<sup>9+</sup>](#off9)替代。 1596 1597**系统能力：** SystemCapability.Utils.Lang 1598 1599**参数：** 1600 1601| 参数名 | 类型 | 必填 | 说明 | 1602| -------- | ----------------------------------------- | ---- | -------------------- | 1603| type | string | 是 | 需要删除的事件类型。 | 1604| listener | [EventListener](#eventlistenerdeprecated) | 否 | 删除监听事件后所执行的回调事件。 | 1605 1606**示例：** 1607 1608```ts 1609const workerInstance = new worker.Worker("workers/worker.ets"); 1610//使用on接口、once接口或addEventListener接口创建“alert”事件，使用off接口删除事件。 1611workerInstance.off("alert"); 1612``` 1613 1614 1615### terminate<sup>(deprecated)</sup> 1616 1617terminate(): void 1618 1619销毁Worker线程，终止Worker接收消息。 1620 1621> **说明：**<br/> 1622> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.terminate<sup>9+</sup>](#terminate9)替代。 1623 1624**系统能力：** SystemCapability.Utils.Lang 1625 1626**示例：** 1627 1628```ts 1629const workerInstance = new worker.Worker("workers/worker.ets"); 1630workerInstance.terminate(); 1631``` 1632 1633 1634### onexit<sup>(deprecated)</sup> 1635 1636onexit?: (code: number) => void 1637 1638回调函数。表示Worker销毁时被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中code类型为number，异常退出为1，正常退出为0。 1639 1640> **说明：**<br/> 1641> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.onexit<sup>9+</sup>](#onexit9)替代。 1642 1643**系统能力：** SystemCapability.Utils.Lang 1644 1645**示例：** 1646 1647```ts 1648const workerInstance = new worker.Worker("workers/worker.ets"); 1649workerInstance.onexit = (code) => { 1650 console.log("onexit"); 1651} 1652 1653//onexit被执行两种方式： 1654//main thread： 1655workerInstance.terminate(); 1656 1657//worker线程： 1658//parentPort.close() 1659``` 1660 1661 1662### onerror<sup>(deprecated)</sup> 1663 1664onerror?: (err: ErrorEvent) => void 1665 1666回调函数。表示Worker在执行过程中发生异常被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中err类型为[ErrorEvent](#errorevent)，表示收到的异常数据。 1667 1668> **说明：**<br/> 1669> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.onerror<sup>9+</sup>](#onerror9)替代。 1670 1671**系统能力：** SystemCapability.Utils.Lang 1672 1673**示例：** 1674 1675```ts 1676import { worker, ErrorEvent } from '@kit.ArkTS'; 1677 1678const workerInstance = new worker.Worker("workers/worker.ets"); 1679workerInstance.onerror = (err: ErrorEvent) => { 1680 console.log("onerror" + err.message); 1681} 1682``` 1683 1684 1685### onmessage<sup>(deprecated)</sup> 1686 1687onmessage?: (event: MessageEvent) => void 1688 1689回调函数。表示宿主线程接收到来自其创建的Worker通过workerPort.postMessage接口发送的消息时被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中event类型为[MessageEvent](#messageeventt)，表示收到的Worker消息数据。 1690 1691> **说明：**<br/> 1692> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.onmessage<sup>9+</sup>](#onmessage9)替代。 1693 1694**系统能力：** SystemCapability.Utils.Lang 1695 1696**示例：** 1697 1698```ts 1699import { worker } from '@kit.ArkTS'; 1700 1701const workerInstance = new worker.Worker("workers/worker.ets"); 1702workerInstance.onmessage = (e): void => { 1703 console.log("onmessage"); 1704} 1705``` 1706 1707 1708### onmessageerror<sup>(deprecated)</sup> 1709 1710onmessageerror?: (event: MessageEvent) => void 1711 1712回调函数。表示当Worker对象接收到一条无法被序列化的消息时被调用的事件处理程序，处理程序在宿主线程中执行。其中回调函数中event类型为[MessageEvent](#messageeventt)，表示收到的Worker消息数据。 1713 1714> **说明：**<br/> 1715> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorker.onmessageerror<sup>9+</sup>](#onmessageerror9)替代。 1716 1717**系统能力：** SystemCapability.Utils.Lang 1718 1719**示例：** 1720 1721```ts 1722import { worker } from '@kit.ArkTS'; 1723 1724const workerInstance = new worker.Worker("workers/worker.ets"); 1725workerInstance.onmessageerror = (err) => { 1726 console.log("onmessageerror"); 1727} 1728``` 1729 1730 1731## EventTarget<sup>(deprecated)</sup> 1732> **说明：**<br/> 1733> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[WorkerEventTarget<sup>9+</sup>](#workereventtarget9)替代。 1734 1735### addEventListener<sup>(deprecated)</sup> 1736 1737addEventListener(type: string, listener: EventListener): void 1738 1739向Worker添加一个事件监听，该接口与[on<sup>(deprecated)</sup>](#ondeprecated)接口功能一致。 1740 1741> **说明：**<br/> 1742> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[addEventListener<sup>9+</sup>](#addeventlistener9)替代。 1743 1744**系统能力：** SystemCapability.Utils.Lang 1745 1746**参数：** 1747 1748| 参数名 | 类型 | 必填 | 说明 | 1749| -------- | ----------------------------------------- | ---- | ---------------- | 1750| type | string | 是 | 监听的事件类型。 | 1751| listener | [EventListener](#eventlistenerdeprecated) | 是 | 回调的事件。 | 1752 1753**示例：** 1754 1755```ts 1756const workerInstance = new worker.Worker("workers/worker.ets"); 1757workerInstance.addEventListener("alert", (e)=>{ 1758 console.log("alert listener callback"); 1759}) 1760``` 1761 1762 1763### removeEventListener<sup>(deprecated)</sup> 1764 1765removeEventListener(type: string, callback?: EventListener): void 1766 1767删除Worker的事件监听，该接口与[off<sup>(deprecated)</sup>](#offdeprecated)接口功能一致。 1768 1769> **说明：**<br/> 1770> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[removeEventListener<sup>9+</sup>](#removeeventlistener9)替代。 1771 1772**系统能力：** SystemCapability.Utils.Lang 1773 1774**参数：** 1775 1776| 参数名 | 类型 | 必填 | 说明 | 1777| -------- | ----------------------------------------- | ---- | ------------------------ | 1778| type | string | 是 | 需要删除的监听事件类型。 | 1779| callback | [EventListener](#eventlistenerdeprecated) | 否 | 删除监听事件后所执行的回调事件。 | 1780 1781**示例：** 1782 1783```ts 1784const workerInstance = new worker.Worker("workers/worker.ets"); 1785workerInstance.addEventListener("alert", (e)=>{ 1786 console.log("alert listener callback"); 1787}) 1788workerInstance.removeEventListener("alert"); 1789``` 1790 1791 1792### dispatchEvent<sup>(deprecated)</sup> 1793 1794dispatchEvent(event: Event): boolean 1795 1796分发定义在Worker的事件。 1797 1798> **说明：**<br/> 1799> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[dispatchEvent<sup>9+</sup>](#dispatchevent9)替代。 1800 1801**系统能力：** SystemCapability.Utils.Lang 1802 1803**参数：** 1804 1805| 参数名 | 类型 | 必填 | 说明 | 1806| ------ | --------------- | ---- | ---------------- | 1807| event | [Event](#event) | 是 | 需要分发的事件。 | 1808 1809**返回值：** 1810 1811| 类型 | 说明 | 1812| ------- | ------------------------------- | 1813| boolean | 分发的结果，false表示分发失败。 | 1814 1815**示例：** 1816 1817```ts 1818const workerInstance = new worker.Worker("workers/worker.ets"); 1819 1820workerInstance.dispatchEvent({type:"eventType", timeStamp:0}); //timeStamp暂未支持。 1821``` 1822 1823分发事件（dispatchEvent）可与监听接口（on、once、addEventListener）搭配使用，示例如下： 1824 1825```ts 1826const workerInstance = new worker.Worker("workers/worker.ets"); 1827 1828//用法一: 1829workerInstance.on("alert_on", (e)=>{ 1830 console.log("alert listener callback"); 1831}) 1832workerInstance.once("alert_once", (e)=>{ 1833 console.log("alert listener callback"); 1834}) 1835workerInstance.addEventListener("alert_add", (e)=>{ 1836 console.log("alert listener callback"); 1837}) 1838 1839//once接口创建的事件执行一次便会删除。 1840workerInstance.dispatchEvent({type:"alert_once", timeStamp:0});//timeStamp暂未支持。 1841//on接口创建的事件可以一直被分发，不能主动删除。 1842workerInstance.dispatchEvent({type:"alert_on", timeStamp:0}); 1843workerInstance.dispatchEvent({type:"alert_on", timeStamp:0}); 1844//addEventListener接口创建的事件可以一直被分发，不能主动删除。 1845workerInstance.dispatchEvent({type:"alert_add", timeStamp:0}); 1846workerInstance.dispatchEvent({type:"alert_add", timeStamp:0}); 1847 1848//用法二: 1849//event类型的type支持自定义，同时存在"message"/"messageerror"/"error"特殊类型，如下所示 1850//当type = "message"，onmessage接口定义的方法同时会执行。 1851//当type = "messageerror"，onmessageerror接口定义的方法同时会执行。 1852//当type = "error"，onerror接口定义的方法同时会执行。 1853//若调用removeEventListener接口或者off接口取消事件时，能且只能取消使用addEventListener/on/once创建的事件。 1854 1855workerInstance.addEventListener("message", (e)=>{ 1856 console.log("message listener callback"); 1857}) 1858workerInstance.onmessage = function(e) { 1859 console.log("onmessage : message listener callback"); 1860} 1861//调用dispatchEvent分发“message”事件，addEventListener和onmessage中定义的方法都会被执行。 1862workerInstance.dispatchEvent({type:"message", timeStamp:0}); 1863``` 1864### removeAllListener<sup>(deprecated)</sup> 1865 1866removeAllListener(): void 1867 1868删除Worker所有的事件监听。 1869 1870> **说明：**<br/> 1871> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[removeAllListener<sup>9+</sup>](#removealllistener9)替代。 1872 1873**系统能力：** SystemCapability.Utils.Lang 1874 1875**示例：** 1876 1877```ts 1878const workerInstance = new worker.Worker("workers/worker.ets"); 1879workerInstance.addEventListener("alert", (e)=>{ 1880 console.log("alert listener callback"); 1881}) 1882workerInstance.removeAllListener(); 1883``` 1884 1885 1886## DedicatedWorkerGlobalScope<sup>(deprecated)</sup> 1887 1888Worker线程用于与宿主线程通信的类，通过postMessage接口发送消息给宿主线程、close接口销毁Worker线程。DedicatedWorkerGlobalScope类继承[WorkerGlobalScope](#workerglobalscopedeprecated)。 1889 1890> **说明：**<br/> 1891> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorkerGlobalScope<sup>9+</sup>](#threadworkerglobalscope9)替代。 1892 1893### postMessage<sup>(deprecated)</sup> 1894 1895postMessage(messageObject: Object, transfer: Transferable[]): void 1896 1897Worker线程通过转移对象所有权的方式向宿主线程发送消息。 1898 1899> **说明：**<br/> 1900> 此接口暂不支持使用，从API version 9 开始废弃，建议使用[ThreadWorkerGlobalScope<sup>9+</sup>.postMessage<sup>9+</sup>](#postmessage9-2)替代。 1901 1902**系统能力：** SystemCapability.Utils.Lang 1903 1904**参数：** 1905 1906| 参数名 | 类型 | 必填 | 说明 | 1907| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 1908| messageObject | Object | 是 | 发送至宿主线程的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 1909| transfer| Transferable[] | 是 | 暂不支持该参数类型。 | 1910 1911### postMessage<sup>9+</sup> 1912 1913postMessage(messageObject: Object, transfer: ArrayBuffer[]): void 1914 1915Worker线程通过转移对象所有权的方式向宿主线程发送消息。 1916 1917> **说明：**<br/> 1918> DedicatedWorkerGlobalScope类自API version 9 开始废弃，本接口建议使用[ThreadWorkerGlobalScope<sup>9+</sup>.postMessage<sup>9+</sup>](#postmessage9-2)替代。 1919 1920**系统能力：** SystemCapability.Utils.Lang 1921 1922**参数：** 1923 1924| 参数名 | 类型 | 必填 | 说明 | 1925| -------- | ------------- | ---- | ------------------------------------------------------------ | 1926| messageObject | Object | 是 | 发送至宿主线程的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 1927| transfer | ArrayBuffer[] | 是 | 表示可转移的ArrayBuffer实例对象数组，该数组中对象的所有权会被转移到宿主线程，在Worker线程中将会变为不可用，仅在宿主线程中可用，数组不可传入null。 | 1928 1929**示例：** 1930 1931```ts 1932// main thread 1933import { worker } from '@kit.ArkTS'; 1934 1935const workerInstance = new worker.Worker("workers/worker.ets"); 1936workerInstance.postMessage("hello world"); 1937workerInstance.onmessage = (e): void => { 1938 // let data = e.data; 1939 console.log("receive data from worker.ets"); 1940} 1941``` 1942```ts 1943// worker.ets 1944import { worker } from '@kit.ArkTS'; 1945 1946const workerPort = worker.workerPort; 1947workerPort.onmessage = (e): void => { 1948 // let data = e.data; 1949 let buffer = new ArrayBuffer(5) 1950 workerPort.postMessage(buffer, [buffer]); 1951} 1952``` 1953 1954### postMessage<sup>(deprecated)</sup> 1955 1956postMessage(messageObject: Object, options?: PostMessageOptions): void 1957 1958Worker线程通过转移对象所有权或者拷贝数据的方式向宿主线程发送消息。 1959 1960> **说明：**<br/> 1961> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorkerGlobalScope<sup>9+</sup>.postMessage<sup>9+</sup>](#postmessage9-3)替代。 1962 1963**系统能力：** SystemCapability.Utils.Lang 1964 1965**参数：** 1966 1967| 参数名 | 类型 | 必填 | 说明 | 1968| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 1969| messageObject | Object | 是 | 发送至宿主线程的数据，该数据对象必须是可序列化，序列化支持类型见[其他说明](#序列化支持类型)。 | 1970| options | [PostMessageOptions](#postmessageoptions) | 否 | 当填入该参数时，与传入ArrayBuffer[]的作用一致，该数组中对象的所有权会被转移到宿主线程，在Worker线程中将会变为不可用，仅在宿主线程中可用。<br/>若不填入该参数，默认设置为 undefined，通过拷贝数据的方式传输信息到宿主线程。 | 1971 1972**示例：** 1973 1974<!--no_check--> 1975```ts 1976// main thread 1977import { worker } from '@kit.ArkTS'; 1978 1979const workerInstance = new worker.Worker("entry/ets/workers/worker.ets"); 1980workerInstance.postMessage("hello world"); 1981workerInstance.onmessage = (): void => { 1982 console.log("receive data from worker.ets"); 1983} 1984``` 1985```ts 1986// worker.ets 1987import { ErrorEvent, MessageEvents, worker } from '@kit.ArkTS'; 1988 1989const parentPort = worker.parentPort; 1990parentPort.onmessage = (e: MessageEvents) => { 1991 parentPort.postMessage("receive data from main thread"); 1992} 1993``` 1994 1995### close<sup>(deprecated)</sup> 1996 1997close(): void 1998 1999销毁Worker线程，终止Worker接收消息。 2000 2001> **说明：**<br/> 2002> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorkerGlobalScope<sup>9+</sup>.close<sup>9+</sup>](#close9)替代。 2003 2004**系统能力：** SystemCapability.Utils.Lang 2005 2006**示例：** 2007 2008```ts 2009// main thread 2010import { worker } from '@kit.ArkTS'; 2011 2012const workerInstance = new worker.Worker("workers/worker.ets"); 2013``` 2014```ts 2015// worker.ets 2016import { worker } from '@kit.ArkTS'; 2017 2018const parentPort = worker.parentPort; 2019parentPort.onmessage = (e): void => { 2020 parentPort.close() 2021} 2022``` 2023 2024 2025### onmessage<sup>(deprecated)</sup> 2026 2027onmessage?: (this: DedicatedWorkerGlobalScope, ev: MessageEvent) => void 2028 2029回调函数，DedicatedWorkerGlobalScope的onmessage属性表示Worker线程收到来自其宿主线程通过postMessage接口发送的消息时被调用的事件处理程序，处理程序在Worker线程中执行。其中this指调用者对象本身[DedicatedWorkerGlobalScope](#dedicatedworkerglobalscopedeprecated)，ev类型为[MessageEvent](#messageeventt)，表示收到的Worker消息数据。 2030 2031> **说明：**<br/> 2032> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorkerGlobalScope<sup>9+</sup>.onmessage<sup>9+</sup>](#onmessage9-1)替代。 2033 2034**系统能力：** SystemCapability.Utils.Lang 2035 2036**示例：** 2037 2038```ts 2039// main thread 2040import { worker } from '@kit.ArkTS'; 2041 2042const workerInstance = new worker.Worker("workers/worker.ets"); 2043workerInstance.postMessage("hello world"); 2044``` 2045```ts 2046// worker.ets 2047import { worker } from '@kit.ArkTS'; 2048 2049const parentPort = worker.parentPort; 2050parentPort.onmessage = (e): void => { 2051 console.log("receive main thread message"); 2052} 2053``` 2054 2055 2056### onmessageerror<sup>(deprecated)</sup> 2057 2058onmessageerror?: (this: DedicatedWorkerGlobalScope, ev: MessageEvent) => void 2059 2060DedicatedWorkerGlobalScope的onmessageerror属性表示当Worker对象接收到一条无法被反序列化的消息时被调用的事件处理程序，处理程序在Worker线程中执行。其中this指调用者对象本身[DedicatedWorkerGlobalScope](#threadworkerglobalscope9)，ev类型为[MessageEvent](#dedicatedworkerglobalscopedeprecated)，表示收到的Worker消息数据。 2061 2062> **说明：**<br/> 2063> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[ThreadWorkerGlobalScope<sup>9+</sup>.onmessageerror<sup>9+</sup>](#onmessageerror9-1)替代。 2064 2065**系统能力：** SystemCapability.Utils.Lang 2066 2067**示例：** 2068 2069```ts 2070// main thread 2071import { worker } from '@kit.ArkTS'; 2072 2073const workerInstance = new worker.Worker("workers/worker.ets"); 2074``` 2075```ts 2076// worker.ets 2077import { worker } from '@kit.ArkTS'; 2078 2079const parentPort = worker.parentPort; 2080parentPort.onmessageerror = (e) => { 2081 console.log("worker.ets onmessageerror") 2082} 2083``` 2084 2085 2086## PostMessageOptions 2087 2088明确数据传递过程中需要转移所有权对象的类，传递所有权的对象必须是ArrayBuffer，发送它的上下文中将会变为不可用，仅在接收方可用。 2089 2090**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2091 2092**系统能力：** SystemCapability.Utils.Lang 2093 2094| 名称 | 类型 | 可读 | 可写 | 说明 | 2095| -------- | -------- | ---- | ---- | --------------------------------- | 2096| transfer | Object[] | 是 | 是 | ArrayBuffer数组，用于传递所有权。该数组中不可传入null。 | 2097 2098 2099## Event 2100 2101事件类。 2102 2103**原子化服务API：** 从API version 12 开始，该接口支持在原子化服务中使用。 2104 2105**系统能力：** SystemCapability.Utils.Lang 2106 2107| 名称 | 类型 | 可读 | 可写 | 说明 | 2108| --------- | ------ | ---- | ---- | -------------------------------------------- | 2109| type | string | 是 | 否 | 指定事件的类型。 | 2110| timeStamp | number | 是 | 否 | 事件创建时的时间戳（精度为毫秒），暂未支持。 | 2111 2112 2113## EventListener<sup>(deprecated)</sup> 2114 2115事件监听类。 2116 2117> **说明：** 2118> 2119> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[WorkerEventListener<sup>9+</sup>](#workereventlistener9)替代。 2120 2121### (evt: Event)<sup>(deprecated)</sup> 2122 2123(evt: Event): void | Promise<void> 2124 2125> **说明：** 2126> 2127> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[(event:Event)<sup>9+</sup>](#event-event9)替代。 2128 2129**系统能力：** SystemCapability.Utils.Lang 2130 2131**参数：** 2132 2133| 参数名 | 类型 | 必填 | 说明 | 2134| ------ | --------------- | ---- | -------------- | 2135| evt | [Event](#event) | 是 | 回调的事件类。 | 2136 2137**返回值：** 2138 2139| 类型 | 说明 | 2140| ------------------------------------- | ------------------------------- | 2141| void \| Promise<void> | 无返回值或者以Promise形式返回。 | 2142 2143**示例：** 2144 2145```ts 2146const workerInstance = new worker.Worker("workers/worker.ets"); 2147workerInstance.addEventListener("alert", (e)=>{ 2148 console.log("alert listener callback"); 2149}) 2150``` 2151 2152 2153## ErrorEvent 2154 2155错误事件类，用于表示Worker执行过程中出现异常的详细信息，ErrorEvent类继承[Event](#event)。 2156 2157**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2158 2159**系统能力：** SystemCapability.Utils.Lang 2160 2161| 名称 | 类型 | 可读 | 可写 | 说明 | 2162| -------- | ------ | ---- | ---- | -------------------- | 2163| message | string | 是 | 否 | 异常发生的错误信息。 | 2164| filename | string | 是 | 否 | 出现异常所在的文件。 | 2165| lineno | number | 是 | 否 | 异常所在的行数。 | 2166| colno | number | 是 | 否 | 异常所在的列数。 | 2167| error | Object | 是 | 否 | 异常类型。 | 2168 2169 2170## MessageEvent\<T\> 2171 2172消息类，持有Worker线程间传递的数据。 2173 2174**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2175 2176**系统能力：** SystemCapability.Utils.Lang 2177 2178| 名称 | 类型 | 可读 | 可写 | 说明 | 2179| ---- | ---- | ---- | ---- | ------------------ | 2180| data | T | 是 | 否 | 线程间传递的数据。 | 2181 2182 2183## WorkerGlobalScope<sup>(deprecated)</sup> 2184 2185Worker线程自身的运行环境，WorkerGlobalScope类继承[EventTarget](#eventtargetdeprecated)。 2186 2187> **说明：**<br/> 2188> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[GlobalScope<sup>9+</sup>](#globalscope9)替代。 2189 2190### 属性 2191 2192**系统能力：** SystemCapability.Utils.Lang 2193 2194| 名称 | 类型 | 可读 | 可写 | 说明 | 2195| ---- | ------------------------------------------------------------ | ---- | ---- | ------------------------------------- | 2196| name | string | 是 | 否 | Worker的名字，new Worker时指定。 | 2197| self | [WorkerGlobalScope](#workerglobalscopedeprecated) & typeof globalThis | 是 | 否 | WorkerGlobalScope本身。 | 2198 2199 2200### onerror<sup>(deprecated)</sup> 2201 2202onerror?: (ev: ErrorEvent) => void 2203 2204WorkerGlobalScope的onerror属性表示Worker在执行过程中发生异常被调用的事件处理程序，处理程序在Worker线程中执行。其中回调函数中ev类型为[ErrorEvent](#errorevent)，表示收到的异常数据。 2205 2206> **说明：**<br/> 2207> 从API version 7 开始支持，从API version 9 开始废弃，建议使用[GlobalScope<sup>9+</sup>.onerror<sup>9+</sup>](#onerror9-1)替代。 2208 2209**系统能力：** SystemCapability.Utils.Lang 2210 2211**示例：** 2212 2213```ts 2214// main thread 2215import { worker } from '@kit.ArkTS'; 2216 2217const workerInstance = new worker.Worker("workers/worker.ets") 2218``` 2219```ts 2220// worker.ets 2221import { worker, ErrorEvent } from '@kit.ArkTS'; 2222 2223const parentPort = worker.parentPort 2224parentPort.onerror = (err: ErrorEvent) => { 2225 console.log("worker.ets onerror" + err.message) 2226} 2227``` 2228 2229 2230## 其他说明 2231 2232### 序列化支持类型 2233 2234序列化支持类型包括：除Symbol之外的基础类型、Date、String、RegExp、Array、Map、Set、Object（仅限简单对象，比如通过"{}"或者"new Object"创建，普通对象仅支持传递属性，不支持传递其原型及方法）、ArrayBuffer、TypedArray。 2235 2236特例：传递通过自定义class创建出来的object时，不会发生序列化错误，但是自定义class的属性（如Function）无法通过序列化传递。 2237> **说明：**<br/> 2238> 以API version 9的FA工程为例。 2239 2240```ts 2241// main thread 2242import { worker, MessageEvents } from '@kit.ArkTS'; 2243 2244const workerInstance = new worker.ThreadWorker("workers/worker.ets"); 2245workerInstance.postMessage("message from main thread to worker"); 2246workerInstance.onmessage = (d: MessageEvents): void => { 2247 // 当worker线程传递obj2时，data即为obj2。data没有Init、SetName的方法 2248 let data: string = d.data; 2249} 2250``` 2251```ts 2252// worker.ets 2253import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS'; 2254 2255const workerPort = worker.workerPort; 2256class MyModel { 2257 name = "undefined" 2258 Init() { 2259 this.name = "MyModel" 2260 } 2261} 2262workerPort.onmessage = (d: MessageEvents): void => { 2263 console.log("worker.ets onmessage"); 2264 let data: string = d.data; 2265 let func1 = () => { 2266 console.log("post message is function"); 2267 } 2268 // workerPort.postMessage(func1); 传递func1发生序列化错误 2269 // let obj1: obj | null = null; 2270 // if (obj1) { 2271 // workerPort.postMessage(obj1 as obj); //传递obj1发生序列化错误 2272 // } 2273 let obj2 = new MyModel(); 2274 workerPort.postMessage(obj2); // 传递obj2不会发生序列化错误 2275} 2276workerPort.onmessageerror = () => { 2277 console.log("worker.ets onmessageerror"); 2278} 2279workerPort.onerror = (err: ErrorEvent) => { 2280 console.log("worker.ets onerror" + err.message); 2281} 2282``` 2283 2284### 内存模型 2285Worker基于Actor并发模型实现。在Worker的交互流程中，JS主线程可以创建多个Worker子线程，各个Worker线程间相互隔离，并通过序列化传递对象，等到Worker线程完成计算任务，再把结果返回给主线程。 2286 2287Actor并发模型的交互原理：各个Actor并发地处理主线程任务，每个Actor内部都有一个消息队列及单线程执行模块，消息队列负责接收主线程及其他Actor的请求，单线程执行模块则负责串行地处理请求、向其他Actor发送请求以及创建新的Actor。由于Actor采用的是异步方式，各个Actor之间相互隔离没有数据竞争，因此Actor可以高并发运行。 2288 2289## 完整示例 2290> **说明：**<br/> 2291> 以API version 9的工程为例。<br> API version 8及之前的版本仅支持FA模型，如需使用，注意更换构造Worker的接口和创建worker线程中与主线程通信的对象的两个方法。 2292### FA模型 2293 2294```ts 2295// main thread(同级目录为例) 2296import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS'; 2297 2298// 主线程中创建Worker对象 2299const workerInstance = new worker.ThreadWorker("workers/worker.ets"); 2300 2301// 主线程向worker线程传递信息 2302workerInstance.postMessage("123"); 2303 2304// 主线程接收worker线程信息 2305workerInstance.onmessage = (e: MessageEvents): void => { 2306 // data：worker线程发送的信息 2307 let data: string = e.data; 2308 console.log("main thread onmessage"); 2309 2310 // 销毁Worker对象 2311 workerInstance.terminate(); 2312} 2313 2314// 在调用terminate后，执行回调onexit 2315workerInstance.onexit = (code) => { 2316 console.log("main thread terminate"); 2317} 2318 2319workerInstance.onerror = (err: ErrorEvent) => { 2320 console.log("main error message " + err.message); 2321} 2322``` 2323```ts 2324// worker.ets 2325import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS'; 2326 2327// 创建worker线程中与主线程通信的对象 2328const workerPort = worker.workerPort 2329 2330// worker线程接收主线程信息 2331workerPort.onmessage = (e: MessageEvents): void => { 2332 // data：主线程发送的信息 2333 let data: string = e.data; 2334 console.log("worker.ets onmessage"); 2335 2336 // worker线程向主线程发送信息 2337 workerPort.postMessage("123") 2338} 2339 2340// worker线程发生error的回调 2341workerPort.onerror = (err: ErrorEvent) => { 2342 console.log("worker.ets onerror"); 2343} 2344``` 2345build-profile.json5 配置 : 2346```json 2347 "buildOption": { 2348 "sourceOption": { 2349 "workers": [ 2350 "./src/main/ets/entryability/workers/worker.ets" 2351 ] 2352 } 2353 } 2354``` 2355### Stage模型 2356```ts 2357// main thread（以不同目录为例） 2358import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS'; 2359 2360// 主线程中创建Worker对象 2361const workerInstance = new worker.ThreadWorker("entry/ets/pages/workers/worker.ets"); 2362 2363// 主线程向worker线程传递信息 2364workerInstance.postMessage("123"); 2365 2366// 主线程接收worker线程信息 2367workerInstance.onmessage = (e: MessageEvents): void => { 2368 // data：worker线程发送的信息 2369 let data: string = e.data; 2370 console.log("main thread onmessage"); 2371 2372 // 销毁Worker对象 2373 workerInstance.terminate(); 2374} 2375// 在调用terminate后，执行onexit 2376workerInstance.onexit = (code) => { 2377 console.log("main thread terminate"); 2378} 2379 2380workerInstance.onerror = (err: ErrorEvent) => { 2381 console.log("main error message " + err.message); 2382} 2383``` 2384```ts 2385// worker.ets 2386import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS'; 2387 2388// 创建worker线程中与主线程通信的对象 2389const workerPort = worker.workerPort 2390 2391// worker线程接收主线程信息 2392workerPort.onmessage = (e: MessageEvents): void => { 2393 // data：主线程发送的信息 2394 let data: string = e.data; 2395 console.log("worker.ets onmessage"); 2396 2397 // worker线程向主线程发送信息 2398 workerPort.postMessage("123") 2399} 2400 2401// worker线程发生error的回调 2402workerPort.onerror = (err: ErrorEvent) => { 2403 console.log("worker.ets onerror" + err.message); 2404} 2405``` 2406build-profile.json5 配置: 2407```json 2408 "buildOption": { 2409 "sourceOption": { 2410 "workers": [ 2411 "./src/main/ets/pages/workers/worker.ets" 2412 ] 2413 } 2414 } 2415``` 2416<!--no_check--> 2417