1# @ohos.taskpool（启动任务池） 2 3任务池（taskpool）作用是为应用程序提供一个多线程的运行环境，降低整体资源的消耗、提高系统的整体性能，且您无需关心线程实例的生命周期。您可以使用任务池API创建后台任务（Task），并对所创建的任务进行如任务执行、任务取消的操作。理论上您可以使用任务池API创建数量不受限制的任务，但是出于内存因素不建议您这样做。此外，不建议您在任务中执行阻塞操作，特别是无限期阻塞操作，长时间的阻塞操作占据工作线程，可能会阻塞其他任务调度，影响您的应用性能。 4 5您所创建的同一优先级任务的执行顺序可以由您决定，任务真实执行的顺序与您调用任务池API提供的任务执行接口顺序一致。任务默认优先级是MEDIUM。 6 7当同一时间待执行的任务数量大于任务池工作线程数量，任务池会根据负载均衡机制进行扩容，增加工作线程数量，减少整体等待时长。同样，当执行的任务数量减少，工作线程数量大于执行任务数量，部分工作线程处于空闲状态，任务池会根据负载均衡机制进行缩容，减少工作线程数量。 8 9任务池API以数字形式返回错误码。有关各个错误码的更多信息，请参阅文档[语言基础类库错误码](errorcode-utils.md)。 10 11taskpool使用过程中的相关注意点请查[TaskPool注意事项](../../arkts-utils/taskpool-introduction.md#taskpool注意事项)。 12 13> **说明：** 14> 15> 本模块首批接口从API version 9 开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 16 17## 导入模块 18 19```ts 20import { taskpool } from '@kit.ArkTS'; 21``` 22## taskpool.execute 23 24execute(func: Function, ...args: Object[]): Promise\<Object> 25 26将待执行的函数放入taskpool内部任务队列，函数不会立即执行，而是等待分发到工作线程执行。当前执行模式不可取消任务。 27 28**系统能力：** SystemCapability.Utils.Lang 29 30**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 31 32**参数：** 33 34| 参数名 | 类型 | 必填 | 说明 | 35| ------ | --------- | ---- | ---------------------------------------------------------------------- | 36| func | Function | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 37| args | Object[] | 否 | 执行逻辑的函数所需要的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 38 39**返回值：** 40 41| 类型 | 说明 | 42| ----------------- | ------------------------------------ | 43| Promise\<Object> | Promise对象，返回任务函数的执行结果。 | 44 45**错误码：** 46 47以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 48 49| 错误码ID | 错误信息 | 50| -------- | -------------------------------------------- | 51| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 52| 10200006 | An exception occurred during serialization. | 53| 10200014 | The function is not marked as concurrent. | 54 55**示例：** 56 57```ts 58@Concurrent 59function printArgs(args: number): number { 60 console.info("printArgs: " + args); 61 return args; 62} 63 64taskpool.execute(printArgs, 100).then((value: Object) => { // 100: test number 65 console.info("taskpool result: " + value); 66}); 67``` 68 69 70## taskpool.execute<sup>13+</sup> 71 72execute<A extends Array\<Object>, R>(func: (...args: A) => R | Promise\<R>, ...args: A): Promise\<R> 73 74校验并发函数的参数类型和返回类型后，将待执行的函数放入taskpool内部任务队列。 75 76**系统能力：** SystemCapability.Utils.Lang 77 78**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 79 80**参数：** 81 82| 参数名 | 类型 | 必填 | 说明 | 83| ------ | --------- | ---- | ---------------------------------------------------------------------- | 84| func | (...args: A) => R \| Promise\<R> | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 85| args | A | 否 | 执行逻辑的函数所需要的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 86 87**返回值：** 88 89| 类型 | 说明 | 90| ----------------- | ------------------------------------ | 91| Promise\<R> | Promise对象，返回任务函数的执行结果。 | 92 93**错误码：** 94 95以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 96 97| 错误码ID | 错误信息 | 98| -------- | -------------------------------------------- | 99| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 100| 10200006 | An exception occurred during serialization. | 101| 10200014 | The function is not marked as concurrent. | 102 103**示例：** 104 105```ts 106@Concurrent 107function printArgs(args: number): number { 108 console.info("printArgs: " + args); 109 return args; 110} 111 112@Concurrent 113function testWithThreeParams(a: number, b: string, c: number): string { 114 return b; 115} 116 117@Concurrent 118function testWithArray(args: [number, string]): string { 119 return "success"; 120} 121 122taskpool.execute<[number], number>(printArgs, 100).then((value: number) => { // 100: test number 123 console.info("taskpool result: " + value); 124}); 125 126taskpool.execute<[number, string, number], string>(testWithThreeParams, 100, "test", 100).then((value: string) => {}) 127 128taskpool.execute<[[number, string]], string>(testWithArray, [100, "test"]).then((value: string) => {}) 129``` 130 131 132## taskpool.execute 133 134execute(task: Task, priority?: Priority): Promise\<Object> 135 136将创建好的任务放入taskpool内部任务队列，任务不会立即执行，而是等待分发到工作线程执行。当前执行模式可以设置任务优先级和尝试调用cancel进行任务取消。该任务不可以是任务组任务和串行队列任务。若该任务非长时任务，可以多次调用执行，长时任务仅支持执行一次。 137 138**系统能力：** SystemCapability.Utils.Lang 139 140**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 141 142**参数：** 143 144| 参数名 | 类型 | 必填 | 说明 | 145| -------- | --------------------- | ---- | ---------------------------------------- | 146| task | [Task](#task) | 是 | 需要在任务池中执行的任务。 | 147| priority | [Priority](#priority) | 否 | 等待执行的任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 148 149**返回值：** 150 151| 类型 | 说明 | 152| ---------------- | ---------------- | 153| Promise\<Object> | Promise对象，返回任务函数的执行结果。 | 154 155**错误码：** 156 157以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 158 159| 错误码ID | 错误信息 | 160| -------- | ------------------------------------------- | 161| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 162| 10200006 | An exception occurred during serialization. | 163| 10200014 | The function is not marked as concurrent. | 164| 10200051 | The periodic task cannot be executed again. | 165 166**示例：** 167 168```ts 169@Concurrent 170function printArgs(args: number): number { 171 console.info("printArgs: " + args); 172 return args; 173} 174 175let task1: taskpool.Task = new taskpool.Task(printArgs, 100); // 100: test number 176let task2: taskpool.Task = new taskpool.Task(printArgs, 200); // 200: test number 177let task3: taskpool.Task = new taskpool.Task(printArgs, 300); // 300: test number 178taskpool.execute(task1, taskpool.Priority.LOW).then((value: Object) => { 179 console.info("taskpool result1: " + value); 180}); 181taskpool.execute(task2, taskpool.Priority.MEDIUM).then((value: Object) => { 182 console.info("taskpool result2: " + value); 183}); 184taskpool.execute(task3, taskpool.Priority.HIGH).then((value: Object) => { 185 console.info("taskpool result3: " + value); 186}); 187``` 188 189 190## taskpool.execute<sup>13+</sup> 191 192execute<A extends Array\<Object>, R>(task: GenericsTask<A, R>, priority?: Priority): Promise\<R> 193 194校验并发函数的参数类型和返回类型后，将创建好的泛型任务放入taskpool内部任务队列。 195 196**系统能力：** SystemCapability.Utils.Lang 197 198**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 199 200**参数：** 201 202| 参数名 | 类型 | 必填 | 说明 | 203| -------- | --------------------- | ---- | ---------------------------------------- | 204| task | [GenericsTask](#genericstask13) | 是 | 需要在任务池中执行的泛型任务。 | 205| priority | [Priority](#priority) | 否 | 等待执行的任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 206 207**返回值：** 208 209| 类型 | 说明 | 210| ---------------- | ---------------- | 211| Promise\<R> | Promise对象，返回任务函数的执行结果。 | 212 213**错误码：** 214 215以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 216 217| 错误码ID | 错误信息 | 218| -------- | ------------------------------------------- | 219| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 220| 10200006 | An exception occurred during serialization. | 221| 10200014 | The function is not marked as concurrent. | 222| 10200051 | The periodic task cannot be executed again. | 223 224**示例：** 225 226```ts 227@Concurrent 228function printArgs(args: number): number { 229 console.info("printArgs: " + args); 230 return args; 231} 232 233let task1: taskpool.Task = new taskpool.GenericsTask<[number], number>(printArgs, 100); // 100: test number 234let task2: taskpool.Task = new taskpool.GenericsTask<[number], number>(printArgs, 200); // 200: test number 235let task3: taskpool.Task = new taskpool.GenericsTask<[number], number>(printArgs, 300); // 300: test number 236taskpool.execute<[number], number>(task1, taskpool.Priority.LOW).then((value: number) => { 237 console.info("taskpool result1: " + value); 238}); 239taskpool.execute<[number], number>(task2, taskpool.Priority.MEDIUM).then((value: number) => { 240 console.info("taskpool result2: " + value); 241}); 242taskpool.execute<[number], number>(task3, taskpool.Priority.HIGH).then((value: number) => { 243 console.info("taskpool result3: " + value); 244}); 245``` 246 247 248## taskpool.execute<sup>10+</sup> 249 250execute(group: TaskGroup, priority?: Priority): Promise<Object[]> 251 252将创建好的任务组放入taskpool内部任务队列，任务组中的任务不会立即执行，而是等待分发到工作线程执行。任务组中任务全部执行完成后，结果数组统一返回。当前执行模式适用于执行一组有关联的任务。 253 254**系统能力：** SystemCapability.Utils.Lang 255 256**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 257 258**参数：** 259 260| 参数名 | 类型 | 必填 | 说明 | 261| --------- | --------------------------- | ---- | -------------------------------------------------------------- | 262| group | [TaskGroup](#taskgroup10) | 是 | 需要在任务池中执行的任务组。 | 263| priority | [Priority](#priority) | 否 | 等待执行的任务组的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 264 265**返回值：** 266 267| 类型 | 说明 | 268| ---------------- | ---------------------------------- | 269| Promise\<Object[]> | Promise对象数组，返回任务函数的执行结果。 | 270 271**错误码：** 272 273以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 274 275| 错误码ID | 错误信息 | 276| -------- | ------------------------------------------- | 277| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 278| 10200006 | An exception occurred during serialization. | 279 280**示例：** 281 282```ts 283@Concurrent 284function printArgs(args: number): number { 285 console.info("printArgs: " + args); 286 return args; 287} 288 289let taskGroup1: taskpool.TaskGroup = new taskpool.TaskGroup(); 290taskGroup1.addTask(printArgs, 10); // 10: test number 291taskGroup1.addTask(printArgs, 20); // 20: test number 292taskGroup1.addTask(printArgs, 30); // 30: test number 293 294let taskGroup2: taskpool.TaskGroup = new taskpool.TaskGroup(); 295let task1: taskpool.Task = new taskpool.Task(printArgs, 100); // 100: test number 296let task2: taskpool.Task = new taskpool.Task(printArgs, 200); // 200: test number 297let task3: taskpool.Task = new taskpool.Task(printArgs, 300); // 300: test number 298taskGroup2.addTask(task1); 299taskGroup2.addTask(task2); 300taskGroup2.addTask(task3); 301taskpool.execute(taskGroup1).then((res: Array<Object>) => { 302 console.info("taskpool execute res is:" + res); 303}); 304taskpool.execute(taskGroup2).then((res: Array<Object>) => { 305 console.info("taskpool execute res is:" + res); 306}); 307``` 308 309## taskpool.executeDelayed<sup>11+</sup> 310 311executeDelayed(delayTime: number, task: Task, priority?: Priority): Promise\<Object> 312 313延时执行任务。当前执行模式可以设置任务优先级和尝试调用cancel进行任务取消。该任务不可以是任务组任务、串行队列任务和周期任务。若该任务非长时任务，可以多次调用executeDelayed执行，长时任务仅支持执行一次。 314 315**系统能力：** SystemCapability.Utils.Lang 316 317**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 318 319**参数：** 320 321| 参数名 | 类型 | 必填 | 说明 | 322| ----------- | ------------- | ---- | -------------------- | 323| delayTime | number | 是 | 延时时间。单位为ms。 | 324| task | [Task](#task) | 是 | 需要延时执行的任务。 | 325| priority | [Priority](#priority) | 否 | 延时执行的任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 326 327**返回值：** 328 329| 类型 | 说明 | 330| ---------------- | ---------------------------------- | 331| Promise\<Object> | Promise对象，返回任务函数的执行结果。 | 332 333**错误码：** 334 335以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 336 337| 错误码ID | 错误信息 | 338| --------- | -------------------------------- | 339| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 340| 10200006 | An exception occurred during serialization. | 341| 10200014 | The function is not marked as concurrent. | 342| 10200028 | The delayTime is less than zero. | 343| 10200051 | The periodic task cannot be executed again. | 344 345**示例：** 346 347```ts 348// import BusinessError 349import { BusinessError } from '@kit.BasicServicesKit' 350 351@Concurrent 352function printArgs(args: number): void { 353 console.info("printArgs: " + args); 354} 355 356let t: number = Date.now(); 357console.info("taskpool start time is: " + t); 358let task: taskpool.Task = new taskpool.Task(printArgs, 100); // 100: test number 359taskpool.executeDelayed(1000, task).then(() => { // 1000:delayTime is 1000ms 360 console.info("taskpool execute success"); 361}).catch((e: BusinessError) => { 362 console.error(`taskpool execute: Code: ${e.code}, message: ${e.message}`); 363}) 364``` 365 366 367## taskpool.executeDelayed<sup>13+</sup> 368 369executeDelayed<A extends Array\<Object>, R>(delayTime: number, task: GenericsTask\<A, R>, priority?: Priority): Promise\<R> 370 371校验并发函数的参数类型和返回类型后，延时执行泛型任务。 372 373**系统能力：** SystemCapability.Utils.Lang 374 375**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 376 377**参数：** 378 379| 参数名 | 类型 | 必填 | 说明 | 380| ----------- | ------------- | ---- | -------------------- | 381| delayTime | number | 是 | 延时时间。单位为ms。 | 382| task | [GenericsTask](#genericstask13) | 是 | 需要延时执行的泛型任务。 | 383| priority | [Priority](#priority) | 否 | 延时执行的任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 384 385**返回值：** 386 387| 类型 | 说明 | 388| ---------------- | ---------------------------------- | 389| Promise\<R> | Promise对象，返回任务函数的执行结果。 | 390 391**错误码：** 392 393以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 394 395| 错误码ID | 错误信息 | 396| --------- | -------------------------------- | 397| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 398| 10200028 | The delayTime is less than zero. | 399| 10200051 | The periodic task cannot be executed again. | 400 401**示例：** 402 403```ts 404// import BusinessError 405import { BusinessError } from '@kit.BasicServicesKit' 406 407@Concurrent 408function printArgs(args: number): string { 409 console.info("printArgs: " + args); 410 return "success"; 411} 412 413let task: taskpool.Task = new taskpool.GenericsTask<[number], string>(printArgs, 100); // 100: test number 414taskpool.executeDelayed<[number], string>(1000, task).then((res: string) => { // 1000:delayTime is 1000ms 415 console.info("taskpool execute success"); 416}).catch((e: BusinessError) => { 417 console.error(`taskpool execute: Code: ${e.code}, message: ${e.message}`); 418}) 419``` 420 421 422## taskpool.executePeriodically<sup>12+</sup> 423 424executePeriodically(period: number, task: Task, priority?: Priority): void 425 426周期执行任务，每隔period时长执行一次任务。当前执行模式支持设置任务优先级和调用cancel取消任务周期执行。周期任务不可以是任务组任务和串行队列任务，不可以再次调用执行接口，不可以拥有依赖关系。 427 428 429**系统能力：** SystemCapability.Utils.Lang 430 431**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 432 433**参数：** 434 435| 参数名 | 类型 | 必填 | 说明 | 436| ----------- | ------------- | ----- | -------------------- | 437| period | number | 是 | 周期时长。单位为ms。 | 438| task | [Task](#task) | 是 | 需要周期执行的任务。 | 439| priority | [Priority](#priority) | 否 | 周期执行的任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 440 441 442**错误码：** 443 444以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 445 446| 错误码ID | 错误信息 | 447| ---------- | -------------------------------- | 448| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 449| 10200006 | An exception occurred during serialization. | 450| 10200014 | The function is not marked as concurrent. | 451| 10200028 | The period is less than zero. | 452| 10200050 | The concurrent task has been executed and cannot be executed periodically. | 453 454 455**示例：** 456 457```ts 458@Concurrent 459function printArgs(args: number): void { 460 console.info("printArgs: " + args); 461} 462 463@Concurrent 464function testExecutePeriodically(args: number): void { 465 let t = Date.now(); 466 while ((Date.now() - t) < args) { 467 continue; 468 } 469 taskpool.Task.sendData(args); // 向宿主线程发送消息 470} 471 472function printResult(data: number): void { 473 console.info("taskpool: data is: " + data); 474} 475 476function taskpoolTest() { 477 try { 478 let task: taskpool.Task = new taskpool.Task(printArgs, 100); // 100: test number 479 taskpool.executePeriodically(1000, task); // 1000: period is 1000ms 480 } catch (e) { 481 console.error(`taskpool execute-1: Code: ${e.code}, message: ${e.message}`); 482 } 483 484 try { 485 let periodicTask: taskpool.Task = new taskpool.Task(testExecutePeriodically, 200); // 200: test number 486 periodicTask.onReceiveData(printResult); 487 taskpool.executePeriodically(1000, periodicTask); // 1000: period is 1000ms 488 } catch (e) { 489 console.error(`taskpool execute-2: Code: ${e.code}, message: ${e.message}`); 490 } 491} 492 493taskpoolTest(); 494``` 495 496 497## taskpool.executePeriodically<sup>13+</sup> 498 499executePeriodically<A extends Array\<Object>, R>(period: number, task: GenericsTask\<A, R>, priority?: Priority): void 500 501校验并发函数的参数类型和返回类型后，周期执行泛型任务，每隔period时长执行一次泛型任务。 502 503 504**系统能力：** SystemCapability.Utils.Lang 505 506**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 507 508**参数：** 509 510| 参数名 | 类型 | 必填 | 说明 | 511| ----------- | ------------- | ----- | -------------------- | 512| period | number | 是 | 周期时长。单位为ms。 | 513| task | [GenericsTask](#genericstask13) | 是 | 需要周期执行的泛型任务。 | 514| priority | [Priority](#priority) | 否 | 周期执行的任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 515 516 517**错误码：** 518 519以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 520 521| 错误码ID | 错误信息 | 522| ---------- | -------------------------------- | 523| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 524| 10200006 | An exception occurred during serialization. | 525| 10200014 | The function is not marked as concurrent. | 526| 10200028 | The period is less than zero. | 527| 10200050 | The concurrent task has been executed and cannot be executed periodically. | 528 529 530**示例：** 531 532```ts 533@Concurrent 534function printArgs(args: number): void { 535 console.info("printArgs: " + args); 536} 537 538@Concurrent 539function testExecutePeriodically(args: number): void { 540 let t = Date.now(); 541 while ((Date.now() - t) < args) { 542 continue; 543 } 544 taskpool.Task.sendData(args); // 向宿主线程发送消息 545} 546 547function printResult(data: number): void { 548 console.info("taskpool: data is: " + data); 549} 550 551function taskpoolTest() { 552 try { 553 let task: taskpool.Task = new taskpool.GenericsTask<[number], void>(printArgs, 100); // 100: test number 554 taskpool.executePeriodically<[number], void>(1000, task); // 1000: period is 1000ms 555 } catch (e) { 556 console.error(`taskpool execute-1: Code: ${e.code}, message: ${e.message}`); 557 } 558 559 try { 560 let periodicTask: taskpool.Task = new taskpool.GenericsTask<[number], void>(testExecutePeriodically, 200); // 200: test number 561 periodicTask.onReceiveData(printResult); 562 taskpool.executePeriodically<[number], void>(1000, periodicTask); // 1000: period is 1000ms 563 } catch (e) { 564 console.error(`taskpool execute-2: Code: ${e.code}, message: ${e.message}`); 565 } 566} 567 568taskpoolTest(); 569``` 570 571 572## taskpool.cancel 573 574cancel(task: Task): void 575 576取消任务池中的任务。当任务在taskpool等待队列中，取消该任务后该任务将不再执行，并返回undefined作为结果；当任务已经在taskpool工作线程执行，取消该任务并不影响任务继续执行，执行结果在catch分支返回，搭配isCanceled使用可以对任务取消行为作出响应。taskpool.cancel对其之前的taskpool.execute/taskpool.executeDelayed生效。 577 578**系统能力：** SystemCapability.Utils.Lang 579 580**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 581 582**参数：** 583 584| 参数名 | 类型 | 必填 | 说明 | 585| ------ | ------------- | ---- | -------------------- | 586| task | [Task](#task) | 是 | 需要取消执行的任务。 | 587 588**错误码：** 589 590以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 591 592| 错误码ID | 错误信息 | 593| -------- | -------------------------------------------- | 594| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 595| 10200015 | The task to cancel does not exist. | 596 597从API version10开始，此接口调用时不再涉及上报错误码10200016。 598 599**正在执行的任务取消示例：** 600 601```ts 602@Concurrent 603function inspectStatus(arg: number): number { 604 // 第一次检查任务是否已经取消并作出响应 605 if (taskpool.Task.isCanceled()) { 606 console.info("task has been canceled before 2s sleep."); 607 return arg + 2; 608 } 609 // 2s sleep 610 let t: number = Date.now(); 611 while (Date.now() - t < 2000) { 612 continue; 613 } 614 // 第二次检查任务是否已经取消并作出响应 615 if (taskpool.Task.isCanceled()) { 616 console.info("task has been canceled after 2s sleep."); 617 return arg + 3; 618 } 619 return arg + 1; 620} 621 622function concurrentFunc() { 623 let task1: taskpool.Task = new taskpool.Task(inspectStatus, 100); // 100: test number 624 let task2: taskpool.Task = new taskpool.Task(inspectStatus, 200); // 200: test number 625 let task3: taskpool.Task = new taskpool.Task(inspectStatus, 300); // 300: test number 626 let task4: taskpool.Task = new taskpool.Task(inspectStatus, 400); // 400: test number 627 let task5: taskpool.Task = new taskpool.Task(inspectStatus, 500); // 500: test number 628 let task6: taskpool.Task = new taskpool.Task(inspectStatus, 600); // 600: test number 629 taskpool.execute(task1).then((res: Object)=>{ 630 console.info("taskpool test result: " + res); 631 }); 632 taskpool.execute(task2); 633 taskpool.execute(task3); 634 taskpool.execute(task4); 635 taskpool.execute(task5); 636 taskpool.execute(task6); 637 // 1s后取消task 638 setTimeout(()=>{ 639 try { 640 taskpool.cancel(task1); 641 } catch (e) { 642 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 643 } 644 }, 1000); 645} 646 647concurrentFunc(); 648``` 649 650## taskpool.cancel<sup>10+</sup> 651 652cancel(group: TaskGroup): void 653 654取消任务池中的任务组。当一个任务组的任务未全部执行结束时取消任务组，返回undefined作为任务组结果。 655 656**系统能力：** SystemCapability.Utils.Lang 657 658**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 659 660**参数：** 661 662| 参数名 | 类型 | 必填 | 说明 | 663| ------- | ----------------------- | ---- | -------------------- | 664| group | [TaskGroup](#taskgroup10) | 是 | 需要取消执行的任务组。 | 665 666**错误码：** 667 668以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 669 670| 错误码ID | 错误信息 | 671| -------- | ------------------------------------------------------- | 672| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 673| 10200018 | The task group to cancel does not exist. | 674 675**示例：** 676 677```ts 678@Concurrent 679function printArgs(args: number): number { 680 let t: number = Date.now(); 681 while (Date.now() - t < 2000) { 682 continue; 683 } 684 console.info("printArgs: " + args); 685 return args; 686} 687 688function concurrentFunc() { 689 let taskGroup1: taskpool.TaskGroup = new taskpool.TaskGroup(); 690 taskGroup1.addTask(printArgs, 10); // 10: test number 691 let taskGroup2: taskpool.TaskGroup = new taskpool.TaskGroup(); 692 taskGroup2.addTask(printArgs, 100); // 100: test number 693 taskpool.execute(taskGroup1).then((res: Array<Object>)=>{ 694 console.info("taskGroup1 res is:" + res); 695 }); 696 taskpool.execute(taskGroup2).then((res: Array<Object>)=>{ 697 console.info("taskGroup2 res is:" + res); 698 }); 699 setTimeout(()=>{ 700 try { 701 taskpool.cancel(taskGroup2); 702 } catch (e) { 703 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 704 } 705 }, 1000); 706} 707 708concurrentFunc(); 709``` 710 711## taskpool.terminateTask<sup>12+</sup> 712 713terminateTask(longTask: LongTask): void 714 715中止任务池中的长时任务，在长时任务执行完成后调用。中止后，执行长时任务的线程可能会被回收。 716 717**系统能力：** SystemCapability.Utils.Lang 718 719**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 720 721**参数：** 722 723| 参数名 | 类型 | 必填 | 说明 | 724| ------ | ------------- | ---- | -------------------- | 725| longTask | [LongTask](#longtask12) | 是 | 需要中止的长时任务。 | 726 727**错误码：** 728 729以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 730 731| 错误码ID | 错误信息 | 732| -------- | -------- | 733| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 734 735**示例：** 736 737```ts 738@Concurrent 739function longTask(arg: number): number { 740 let t: number = Date.now(); 741 while (Date.now() - t < arg) { 742 continue; 743 } 744 console.info("longTask has been executed."); 745 return arg; 746} 747 748function concurrentFunc() { 749 let task1: taskpool.LongTask = new taskpool.LongTask(longTask, 1000); // 1000: sleep time 750 taskpool.execute(task1).then((res: Object)=>{ 751 taskpool.terminateTask(task1); 752 console.info("taskpool longTask result: " + res); 753 }); 754} 755 756concurrentFunc(); 757``` 758 759## taskpool.isConcurrent<sup>12+</sup> 760 761isConcurrent(func: Function): boolean 762 763检查函数是否为并发函数。 764 765**系统能力：** SystemCapability.Utils.Lang 766 767**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 768 769**参数：** 770 771| 参数名 | 类型 | 必填 | 说明 | 772| ------ | ------------- | ---- | -------------------- | 773| func | Function | 是 | 需要检查的函数。 | 774 775**返回值：** 776 777| 类型 | 说明 | 778| ------- | ------------------------------------ | 779| boolean | 如果被检查函数标注了[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)，返回true，否则返回false。 | 780 781**错误码：** 782 783以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 784 785| 错误码ID | 错误信息 | 786| -------- | -------- | 787| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 788 789**示例：** 790 791```ts 792@Concurrent 793function test() {} 794 795let result: Boolean = taskpool.isConcurrent(test) 796console.info("result is: " + result) 797``` 798 799## taskpool.getTaskPoolInfo<sup>10+</sup> 800 801getTaskPoolInfo(): TaskPoolInfo 802 803获取任务池内部信息，包含线程信息和任务信息。 804 805**系统能力：** SystemCapability.Utils.Lang 806 807**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 808 809**返回值：** 810 811| 类型 | 说明 | 812| ----------------------------------- | ------------------ | 813| [TaskPoolInfo](#taskpoolinfo10) | 任务池的内部信息。 | 814 815**示例：** 816 817```ts 818let taskpoolInfo: taskpool.TaskPoolInfo = taskpool.getTaskPoolInfo(); 819``` 820 821## Priority 822 823表示所创建任务（Task）执行时的优先级。工作线程优先级跟随任务优先级同步更新，对应关系参考[QoS等级定义](../../napi/qos-guidelines.md#qos等级定义)。 824 825**系统能力：** SystemCapability.Utils.Lang 826 827| 名称 | 值 | 说明 | 828| -------- | -------- | -------- | 829| HIGH | 0 | 任务为高优先级。<br/>**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 830| MEDIUM | 1 | 任务为中优先级。<br/>**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 831| LOW | 2 | 任务为低优先级。<br/>**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 832| IDLE<sup>12+</sup> | 3 | 任务为后台任务。<br/>**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 | 833 834**示例：** 835 836```ts 837@Concurrent 838function printArgs(args: number): number { 839 let t: number = Date.now(); 840 while (Date.now() - t < 1000) { // 1000: delay 1s 841 continue; 842 } 843 console.info("printArgs: " + args); 844 return args; 845} 846 847let allCount = 100; // 100: test number 848let taskArray: Array<taskpool.Task> = []; 849// 创建400个任务并添加至taskArray 850for (let i: number = 0; i < allCount; i++) { 851 let task1: taskpool.Task = new taskpool.Task(printArgs, i); 852 taskArray.push(task1); 853 let task2: taskpool.Task = new taskpool.Task(printArgs, i * 10); // 10: test number 854 taskArray.push(task2); 855 let task3: taskpool.Task = new taskpool.Task(printArgs, i * 100); // 100: test number 856 taskArray.push(task3); 857 let task4: taskpool.Task = new taskpool.Task(printArgs, i * 1000); // 1000: test number 858 taskArray.push(task4); 859} 860 861// 从taskArray中获取不同的任务并给定不同优先级执行 862for (let i: number = 0; i < taskArray.length; i+=4) { // 4: 每次执行4个任务，循环取任务时需后移4项，确保执行的是不同的任务 863 taskpool.execute(taskArray[i], taskpool.Priority.HIGH); 864 taskpool.execute(taskArray[i + 1], taskpool.Priority.LOW); 865 taskpool.execute(taskArray[i + 2], taskpool.Priority.MEDIUM); 866 taskpool.execute(taskArray[i + 3], taskpool.Priority.IDLE); 867} 868``` 869 870## Task 871 872表示任务。使用[constructor](#constructor)方法构造Task。任务可以多次执行或放入任务组执行或放入串行队列执行或添加依赖关系执行。 873 874### 属性 875 876**系统能力：** SystemCapability.Utils.Lang 877 878**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 879 880| 名称 | 类型 | 可读 | 可写 | 说明 | 881| -------------------- | --------- | ---- | ---- | ------------------------------------------------------------ | 882| function | Function | 是 | 是 | 创建任务时需要传入的函数，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 883| arguments | Object[] | 是 | 是 | 创建任务传入函数所需的参数，支持的参数类型请查[序列化支持类型](#序列化支持类型)。 | 884| name<sup>11+</sup> | string | 是 | 否 | 创建任务时指定的任务名称。 | 885| totalDuration<sup>11+</sup> | number | 是 | 否 | 执行任务总耗时。 | 886| ioDuration<sup>11+</sup> | number | 是 | 否 | 执行任务异步IO耗时。 | 887| cpuDuration<sup>11+</sup> | number | 是 | 否 | 执行任务CPU耗时。 | 888 889### constructor 890 891constructor(func: Function, ...args: Object[]) 892 893Task的构造函数。 894 895**系统能力：** SystemCapability.Utils.Lang 896 897**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 898 899**参数：** 900 901| 参数名 | 类型 | 必填 | 说明 | 902| ------ | --------- | ---- | -------------------------------------------------------------------- | 903| func | Function | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 904| args | Object[] | 否 | 任务执行传入函数的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 905 906**错误码：** 907 908以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 909 910| 错误码ID | 错误信息 | 911| -------- | --------------------------------------- | 912| 401 | The input parameters are invalid. | 913| 10200014 | The function is not marked as concurrent. | 914 915**示例：** 916 917```ts 918@Concurrent 919function printArgs(args: number): number { 920 console.info("printArgs: " + args); 921 return args; 922} 923 924let task: taskpool.Task = new taskpool.Task(printArgs, "this is my first Task"); 925``` 926 927### constructor<sup>11+</sup> 928 929constructor(name: string, func: Function, ...args: Object[]) 930 931Task的构造函数，可以指定任务名称。 932 933**系统能力：** SystemCapability.Utils.Lang 934 935**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 936 937**参数：** 938 939| 参数名 | 类型 | 必填 | 说明 | 940| ------ | -------- | ---- | ------------------------------------------------------------ | 941| name | string | 是 | 任务名称。 | 942| func | Function | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 943| args | Object[] | 否 | 任务执行传入函数的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 944 945**错误码：** 946 947以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 948 949| 错误码ID | 错误信息 | 950| -------- | --------------------------------------- | 951| 401 | The input parameters are invalid. | 952| 10200014 | The function is not marked as concurrent. | 953 954**示例：** 955 956```ts 957@Concurrent 958function printArgs(args: string): string { 959 console.info("printArgs: " + args); 960 return args; 961} 962 963let taskName: string = "taskName"; 964let task: taskpool.Task = new taskpool.Task(taskName, printArgs, "this is my first Task"); 965let name: string = task.name; 966``` 967 968### isCanceled<sup>10+</sup> 969 970static isCanceled(): boolean 971 972检查当前正在运行的任务是否已取消。使用该方法前需要先构造Task。 973 974**系统能力：** SystemCapability.Utils.Lang 975 976**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 977 978**返回值：** 979 980| 类型 | 说明 | 981| ------- | ------------------------------------ | 982| boolean | 如果当前正在运行的任务被取消返回true，未被取消返回false。| 983 984**示例：** 985 986```ts 987@Concurrent 988function inspectStatus(arg: number): number { 989 // do something 990 if (taskpool.Task.isCanceled()) { 991 console.info("task has been canceled."); 992 // do something 993 return arg + 1; 994 } 995 // do something 996 return arg; 997} 998``` 999 1000> **说明：** 1001> 1002> isCanceled方法需要和taskpool.cancel方法搭配使用，如果不调用cancel方法，isCanceled方法默认返回false。 1003 1004**示例：** 1005 1006```ts 1007@Concurrent 1008function inspectStatus(arg: number): number { 1009 // 第一次检查任务是否已经取消并作出响应 1010 if (taskpool.Task.isCanceled()) { 1011 console.info("task has been canceled before 2s sleep."); 1012 return arg + 2; 1013 } 1014 // 延时2s 1015 let t: number = Date.now(); 1016 while (Date.now() - t < 2000) { 1017 continue; 1018 } 1019 // 第二次检查任务是否已经取消并作出响应 1020 if (taskpool.Task.isCanceled()) { 1021 console.info("task has been canceled after 2s sleep."); 1022 return arg + 3; 1023 } 1024 return arg + 1; 1025} 1026 1027let task: taskpool.Task = new taskpool.Task(inspectStatus, 100); // 100: test number 1028taskpool.execute(task).then((res: Object)=>{ 1029 console.info("taskpool test result: " + res); 1030}).catch((err: string) => { 1031 console.error("taskpool test occur error: " + err); 1032}); 1033// 不调用cancel，isCanceled()默认返回false，task执行的结果为101 1034``` 1035 1036### setTransferList<sup>10+</sup> 1037 1038setTransferList(transfer?: ArrayBuffer[]): void 1039 1040设置任务的传输列表。使用该方法前需要先构造Task。不调用该接口，则传给任务的数据中的ArrayBuffer默认transfer转移。 1041 1042> **说明：** 1043> 1044> 此接口可以设置任务池中ArrayBuffer的transfer列表，transfer列表中的ArrayBuffer对象在传输时不会复制buffer内容到工作线程而是转移buffer控制权至工作线程，传输后当前的ArrayBuffer失效。若ArrayBuffer为空，则不会transfer转移。 1045 1046**系统能力：** SystemCapability.Utils.Lang 1047 1048**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1049 1050**参数：** 1051 1052| 参数名 | 类型 | 必填 | 说明 | 1053| -------- | ------------- | ---- | --------------------------------------------- | 1054| transfer | ArrayBuffer[] | 否 | 可传输对象是ArrayBuffer的实例对象，默认为空数组。 | 1055 1056**错误码：** 1057 1058以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1059 1060| 错误码ID | 错误信息 | 1061| -------- | -------------------------------------------------------------- | 1062| 401 | Parameter error. Possible causes: 1. Incorrect parameter types; 2. Parameter verification failed. | 1063| 10200029 | An ArrayBuffer cannot be set as both a transfer list and a clone list. | 1064 1065**示例：** 1066 1067```ts 1068@Concurrent 1069function testTransfer(arg1: ArrayBuffer, arg2: ArrayBuffer): number { 1070 console.info("testTransfer arg1 byteLength: " + arg1.byteLength); 1071 console.info("testTransfer arg2 byteLength: " + arg2.byteLength); 1072 return 100; 1073} 1074 1075let buffer: ArrayBuffer = new ArrayBuffer(8); 1076let view: Uint8Array = new Uint8Array(buffer); 1077let buffer1: ArrayBuffer = new ArrayBuffer(16); 1078let view1: Uint8Array = new Uint8Array(buffer1); 1079 1080console.info("testTransfer view byteLength: " + view.byteLength); 1081console.info("testTransfer view1 byteLength: " + view1.byteLength); 1082// 执行结果为： 1083// testTransfer view byteLength: 8 1084// testTransfer view1 byteLength: 16 1085 1086let task: taskpool.Task = new taskpool.Task(testTransfer, view, view1); 1087task.setTransferList([view.buffer, view1.buffer]); 1088taskpool.execute(task).then((res: Object)=>{ 1089 console.info("test result: " + res); 1090}).catch((e: string)=>{ 1091 console.error("test catch: " + e); 1092}) 1093console.info("testTransfer view2 byteLength: " + view.byteLength); 1094console.info("testTransfer view3 byteLength: " + view1.byteLength); 1095// 经过transfer转移之后值为0，执行结果为： 1096// testTransfer view2 byteLength: 0 1097// testTransfer view3 byteLength: 0 1098``` 1099 1100 1101### setCloneList<sup>11+</sup> 1102 1103setCloneList(cloneList: Object[] | ArrayBuffer[]): void 1104 1105设置任务的拷贝列表。使用该方法前需要先构造Task。 1106 1107> **说明：** 1108> 1109> 需搭配[@Sendable装饰器](../../arkts-utils/arkts-sendable.md#sendable装饰器)使用，否则会抛异常。 1110 1111**系统能力：** SystemCapability.Utils.Lang 1112 1113**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1114 1115**参数：** 1116 1117| 参数名 | 类型 | 必填 | 说明 | 1118| --------- | ------------------------ | ---- | --------------------------------------------- | 1119| cloneList | Object[] \| ArrayBuffer[] | 是 | - 传入数组的类型必须为[Sendable支持的数据类型](../../arkts-utils/arkts-sendable.md#sendable支持的数据类型)或ArrayBuffer。<br/>- 所有传入cloneList的对象持有的[Sendable class](../../arkts-utils/arkts-sendable.md#sendable-class)实例或ArrayBuffer类型对象，在线程间传输的行为都会变成拷贝传递，即修改传输后的对象不会对原有对象产生任何影响。 | 1120 1121**错误码：** 1122 1123以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1124 1125| 错误码ID | 错误信息 | 1126| -------- | -------------------------------------------------------------- | 1127| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1128| 10200029 | An ArrayBuffer cannot be set as both a transfer list and a clone list. | 1129 1130**示例：** 1131 1132```ts 1133// sendable.ets 1134// 定义两个Sendable class：BaseClass及其子类DeriveClass 1135@Sendable 1136export class BaseClass { 1137 private str: string = "sendable: BaseClass"; 1138 static num :number = 10; 1139 str1: string = "sendable: this is BaseClass's string"; 1140 num1: number = 5; 1141 isDone1: boolean = false; 1142 1143 private fibonacciRecursive(n: number): number { 1144 if (n <= 1) { 1145 return n; 1146 } else { 1147 return this.fibonacciRecursive(n - 1) + this.fibonacciRecursive(n - 2); 1148 } 1149 } 1150 1151 private privateFunc(num: number): number{ 1152 let res: number = this.fibonacciRecursive(num); 1153 console.info("sendable: BaseClass privateFunc res is: " + res); 1154 return res; 1155 } 1156 1157 publicFunc(num: number): number { 1158 return this.privateFunc(num); 1159 } 1160 1161 get GetNum(): number { 1162 return this.num1; 1163 } 1164 set SetNum(num: number) { 1165 this.num1 = num; 1166 } 1167 1168 constructor(){ 1169 console.info(this.str); 1170 this.isDone1 = true; 1171 } 1172} 1173 1174@Sendable 1175export class DeriveClass extends BaseClass { 1176 name: string = "sendable: this is DeriveClass"; 1177 printName() { 1178 console.info(this.name); 1179 } 1180 constructor() { 1181 super(); 1182 } 1183} 1184``` 1185 1186<!--code_no_check--> 1187```ts 1188// index.ets 1189// 宿主线程（这里的宿主线程为UI主线程）调用taskpool，在taskpool线程中调用BaseClass和DeriveClass的方法、访问对应属性 1190import { taskpool } from '@kit.ArkTS' 1191import { BusinessError } from '@kit.BasicServicesKit' 1192import { BaseClass, DeriveClass } from './sendable' 1193 1194@Concurrent 1195function testFunc(arr: Array<BaseClass>, num: number): number { 1196 let baseInstance1 = arr[0]; 1197 console.info("sendable: str1 is: " + baseInstance1.str1); 1198 baseInstance1.SetNum = 100; 1199 console.info("sendable: num1 is: " + baseInstance1.GetNum); 1200 console.info("sendable: isDone1 is: " + baseInstance1.isDone1); 1201 // 获取斐波那契数列第num项的结果 1202 let res: number = baseInstance1.publicFunc(num); 1203 return res; 1204} 1205 1206@Concurrent 1207function printLog(arr: Array<DeriveClass>): void { 1208 let deriveInstance = arr[0]; 1209 deriveInstance.printName(); 1210} 1211 1212@Entry 1213@Component 1214struct Index { 1215 @State message: string = 'Hello World' 1216 1217 build() { 1218 Row() { 1219 Column() { 1220 Text(this.message) 1221 .fontSize(50) 1222 .fontWeight(FontWeight.Bold) 1223 Button() { 1224 Text("TaskPool Test") 1225 }.onClick(() => { 1226 // task1访问调用BaseClass.str1/BaseClass.SetNum/BaseClass.GetNum/BaseClass.isDone1/BaseClass.publicFunc 1227 let baseInstance1: BaseClass = new BaseClass(); 1228 let array1 = new Array<BaseClass>(); 1229 array1.push(baseInstance1); 1230 let task1 = new taskpool.Task(testFunc, array1, 10); 1231 task1.setCloneList(array1); 1232 taskpool.execute(task1).then((res: Object) => { 1233 console.info("sendable: task1 res is: " + res); 1234 }).catch((e:BusinessError) => { 1235 console.error(`sendable: task1 execute Code is ${e.code}, message is ${e.message}`); 1236 }) 1237 1238 // task2调用DeriveClass.printName 1239 let deriveInstance: DeriveClass = new DeriveClass(); 1240 let array2 = new Array<DeriveClass>(); 1241 array2.push(deriveInstance); 1242 let task2 = new taskpool.Task(printLog, array2); 1243 task2.setCloneList(array2); 1244 taskpool.execute(task2).then(() => { 1245 console.info("sendable: task2 execute success"); 1246 }).catch((e:BusinessError) => { 1247 console.error(`sendable: task2 execute Code is ${e.code}, message is ${e.message}`); 1248 }) 1249 }) 1250 .height('15%') 1251 .width('30%') 1252 } 1253 .width('100%') 1254 } 1255 .height('100%') 1256 } 1257} 1258``` 1259 1260 1261### sendData<sup>11+</sup> 1262 1263static sendData(...args: Object[]): void 1264 1265在任务执行过程中向宿主线程发送消息并触发回调。使用该方法前需要先构造Task。 1266 1267> **说明：** 1268> 1269> - 该接口在taskpool的线程中调用。 1270> - 避免在回调函数中使用该方法。 1271> - 调用该接口时确保处理数据的回调函数在宿主线程已注册。 1272 1273**系统能力：** SystemCapability.Utils.Lang 1274 1275**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1276 1277**参数：** 1278 1279| 参数名 | 类型 | 必填 | 说明 | 1280| -------- | ------------- | ---- | ------------------------------------------------- | 1281| args | Object[] | 否 | 可传输对象默认转移，作为回调函数的参数，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 1282 1283**错误码：** 1284 1285以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1286 1287| 错误码ID | 错误信息 | 1288| -------- | --------------------------------------- | 1289| 401 | The input parameters are invalid. | 1290| 10200006 | An exception occurred during serialization. | 1291| 10200022 | The function is not called in the TaskPool thread. | 1292| 10200023 | The function is not called in the concurrent function. | 1293| 10200024 | The callback is not registered on the host side. | 1294 1295**示例：** 1296 1297```ts 1298@Concurrent 1299function sendDataTest(num: number): number { 1300 let res: number = num * 10; 1301 taskpool.Task.sendData(res); 1302 return num; 1303} 1304 1305function printLog(data: number): void { 1306 console.info("taskpool: data is: " + data); 1307} 1308 1309async function taskpoolTest(): Promise<void> { 1310 try { 1311 let task: taskpool.Task = new taskpool.Task(sendDataTest, 1); 1312 task.onReceiveData(printLog); 1313 await taskpool.execute(task); 1314 } catch (e) { 1315 console.error(`taskpool: error code: ${e.code}, info: ${e.message}`); 1316 } 1317} 1318 1319taskpoolTest(); 1320``` 1321 1322 1323### onReceiveData<sup>11+</sup> 1324 1325onReceiveData(callback?: Function): void 1326 1327为任务注册回调函数，以接收和处理来自任务池工作线程的数据。使用该方法前需要先构造Task。 1328 1329> **说明：** 1330> 1331> 不支持给同一个任务定义多种回调函数，如果重复赋值只有最后一个会生效。 1332 1333**系统能力：** SystemCapability.Utils.Lang 1334 1335**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1336 1337**参数：** 1338 1339| 参数名 | 类型 | 必填 | 说明 | 1340| -------- | -------- | ---- | ------------------------------------------------------------ | 1341| callback | Function | 否 | 处理数据的回调函数，发送到宿主线程的数据将会作为入参传入该回调函数。不传参可以取消注册的回调函数。 | 1342 1343**错误码：** 1344 1345以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1346 1347| 错误码ID | 错误信息 | 1348| -------- | -------- | 1349| 401 | Parameter error. Possible causes: 1. Incorrect parameter types; 2. Parameter verification failed. | 1350 1351**示例：** 1352 1353```ts 1354@Concurrent 1355function ConcurrentFunc(num: number): number { 1356 let res: number = num * 10; 1357 taskpool.Task.sendData(res); 1358 return num; 1359} 1360 1361function printLog(data: number): void { 1362 console.info("taskpool: data is: " + data); 1363} 1364 1365async function testFunc(): Promise<void> { 1366 try { 1367 let task: taskpool.Task = new taskpool.Task(ConcurrentFunc, 1); 1368 task.onReceiveData(printLog); 1369 await taskpool.execute(task); 1370 } catch (e) { 1371 console.error(`taskpool: error code: ${e.code}, info: ${e.message}`); 1372 } 1373} 1374 1375testFunc(); 1376``` 1377 1378### addDependency<sup>11+</sup> 1379 1380addDependency(...tasks: Task[]): void 1381 1382为当前任务添加对其他任务的依赖。使用该方法前需要先构造Task。该任务和被依赖的任务不可以是任务组任务、串行队列任务、已执行的任务和周期任务。存在依赖关系的任务（依赖其他任务的任务或被依赖的任务）执行后不可以再次执行。 1383 1384**系统能力：** SystemCapability.Utils.Lang 1385 1386**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1387 1388**参数：** 1389 1390| 参数名 | 类型 | 必填 | 说明 | 1391| ------ | --------------- | ---- | ------------------ | 1392| tasks | [Task](#task)[] | 否 | 被依赖的任务数组。默认值为undefined。 | 1393 1394**错误码：** 1395 1396以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1397 1398| 错误码ID | 错误信息 | 1399| -------- | ------------------------------- | 1400| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1401| 10200026 | There is a circular dependency. | 1402| 10200052 | The periodic task cannot have a dependency. | 1403 1404**示例：** 1405 1406```ts 1407@Concurrent 1408function delay(args: number): number { 1409 let t: number = Date.now(); 1410 while ((Date.now() - t) < 1000) { 1411 continue; 1412 } 1413 return args; 1414} 1415 1416let task1:taskpool.Task = new taskpool.Task(delay, 100); 1417let task2:taskpool.Task = new taskpool.Task(delay, 200); 1418let task3:taskpool.Task = new taskpool.Task(delay, 200); 1419 1420console.info("dependency: add dependency start"); 1421task1.addDependency(task2); 1422task2.addDependency(task3); 1423console.info("dependency: add dependency end"); 1424 1425console.info("dependency: start execute second") 1426taskpool.execute(task1).then(() => { 1427 console.info("dependency: second task1 success"); 1428}) 1429taskpool.execute(task2).then(() => { 1430 console.info("dependency: second task2 success"); 1431}) 1432taskpool.execute(task3).then(() => { 1433 console.info("dependency: second task3 success"); 1434}) 1435``` 1436 1437### removeDependency<sup>11+</sup> 1438 1439removeDependency(...tasks: Task[]): void 1440 1441删除当前任务对其他任务的依赖。使用该方法前需要先构造Task。 1442 1443**系统能力：** SystemCapability.Utils.Lang 1444 1445**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1446 1447**参数：** 1448 1449| 参数名 | 类型 | 必填 | 说明 | 1450| ------ | ------ | ---- | ------------------ | 1451| tasks | [Task](#task)[] | 否 | 被依赖的任务数组。默认值为undefined。 | 1452 1453**错误码：** 1454 1455以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1456 1457| 错误码ID | 错误信息 | 1458| -------- | ------------------------------ | 1459| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1460| 10200027 | The dependency does not exist. | 1461| 10200052 | The periodic task cannot have a dependency. | 1462 1463**示例：** 1464 1465```ts 1466@Concurrent 1467function delay(args: number): number { 1468 let t: number = Date.now(); 1469 while ((Date.now() - t) < 1000) { 1470 continue; 1471 } 1472 return args; 1473} 1474 1475let task1:taskpool.Task = new taskpool.Task(delay, 100); 1476let task2:taskpool.Task = new taskpool.Task(delay, 200); 1477let task3:taskpool.Task = new taskpool.Task(delay, 200); 1478 1479console.info("dependency: add dependency start"); 1480task1.addDependency(task2); 1481task2.addDependency(task3); 1482console.info("dependency: add dependency end"); 1483console.info("dependency: remove dependency start"); 1484task1.removeDependency(task2); 1485task2.removeDependency(task3); 1486console.info("dependency: remove dependency end"); 1487 1488console.info("dependency: start execute") 1489taskpool.execute(task1).then(() => { 1490 console.info("dependency: task1 success"); 1491}) 1492taskpool.execute(task2).then(() => { 1493 console.info("dependency: task2 success"); 1494}) 1495taskpool.execute(task3).then(() => { 1496 console.info("dependency: task3 success"); 1497}) 1498``` 1499 1500 1501### onEnqueued<sup>12+</sup> 1502 1503onEnqueued(callback: CallbackFunction): void 1504 1505注册一个回调函数，并在任务入队时调用它。需在任务执行前注册，否则会抛异常。 1506 1507**系统能力：** SystemCapability.Utils.Lang 1508 1509**原子化服务API**：从API version 12开始，该接口支持在原子化服务中使用。 1510 1511**参数：** 1512 1513| 参数名 | 类型 | 必填 | 说明 | 1514| ------ | ------ | ---- | ------------------ | 1515| callback | [CallbackFunction](#callbackfunction12) | 是 | 需注册的回调函数。 | 1516 1517**错误码：** 1518 1519以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1520 1521| 错误码ID | 错误信息 | 1522| -------- | ------------------------------ | 1523| 401 | The input parameters are invalid. | 1524| 10200034 | The executed task does not support the registration of listeners. | 1525 1526**示例：** 1527 1528```ts 1529import { taskpool } from '@kit.ArkTS' 1530 1531@Concurrent 1532function delay(args: number): number { 1533 let t: number = Date.now(); 1534 while ((Date.now() - t) < 1000) { 1535 continue; 1536 } 1537 return args; 1538} 1539 1540let task: taskpool.Task = new taskpool.Task(delay, 1); 1541task.onEnqueued(()=>{ 1542 console.info("taskpool: onEnqueued") 1543}); 1544taskpool.execute(task).then(()=> { 1545 console.info("taskpool: execute task success") 1546}); 1547``` 1548 1549 1550### onStartExecution<sup>12+</sup> 1551 1552onStartExecution(callback: CallbackFunction): void 1553 1554注册一个回调函数，并在执行任务前调用它。需在任务执行前注册，否则会抛异常。 1555 1556**系统能力：** SystemCapability.Utils.Lang 1557 1558**原子化服务API**：从API version 12开始，该接口支持在原子化服务中使用。 1559 1560**参数：** 1561 1562| 参数名 | 类型 | 必填 | 说明 | 1563| ------ | ------ | ---- | ------------------ | 1564| callback | [CallbackFunction](#callbackfunction12) | 是 | 需注册的回调函数。 | 1565 1566**错误码：** 1567 1568以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1569 1570| 错误码ID | 错误信息 | 1571| -------- | ------------------------------ | 1572| 401 | The input parameters are invalid. | 1573| 10200034 | The executed task does not support the registration of listeners. | 1574 1575**示例：** 1576 1577```ts 1578import { taskpool } from '@kit.ArkTS' 1579 1580@Concurrent 1581function delay(args: number): number { 1582 let t: number = Date.now(); 1583 while ((Date.now() - t) < 1000) { 1584 continue; 1585 } 1586 return args; 1587} 1588 1589let task: taskpool.Task = new taskpool.Task(delay, 1); 1590task.onStartExecution(()=>{ 1591 console.info("taskpool: onStartExecution") 1592}); 1593taskpool.execute(task).then(()=> { 1594 console.info("taskpool: execute task success") 1595}); 1596``` 1597 1598### onExecutionFailed<sup>12+</sup> 1599 1600onExecutionFailed(callback: CallbackFunctionWithError): void 1601 1602注册一个回调函数，并在任务执行失败时调用它。需在任务执行前注册，否则会抛异常。 1603 1604**系统能力：** SystemCapability.Utils.Lang 1605 1606**原子化服务API**：从API version 12开始，该接口支持在原子化服务中使用。 1607 1608**参数：** 1609 1610| 参数名 | 类型 | 必填 | 说明 | 1611| ------ | ------ | ---- | ------------------ | 1612| callback | [CallbackFunctionWithError](#callbackfunctionwitherror12) | 是 | 需注册的回调函数。 | 1613 1614**错误码：** 1615 1616以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1617 1618| 错误码ID | 错误信息 | 1619| -------- | ------------------------------ | 1620| 401 | The input parameters are invalid. | 1621| 10200034 | The executed task does not support the registration of listeners. | 1622 1623**示例：** 1624 1625```ts 1626import { taskpool } from '@kit.ArkTS' 1627import { BusinessError } from '@kit.BasicServicesKit' 1628import { HashMap } from '@kit.ArkTS' 1629 1630@Concurrent 1631function test(args:number) { 1632 let t = Date.now() 1633 while ((Date.now() - t) < 100) { 1634 continue; 1635 } 1636 let hashMap1: HashMap<string, number> = new HashMap(); 1637 hashMap1.set('a', args); 1638 return hashMap1; 1639} 1640 1641let task2 = new taskpool.Task(test, 1); 1642task2.onExecutionFailed((e:Error)=>{ 1643 console.info("taskpool: onExecutionFailed error is " + e); 1644}) 1645taskpool.execute(task2).then(()=>{ 1646 console.info("taskpool: execute task success") 1647}).catch((e:BusinessError)=>{ 1648 console.error(`taskpool: error code: ${e.code}, error info: ${e.message}`); 1649}) 1650``` 1651 1652### onExecutionSucceeded<sup>12+</sup> 1653 1654onExecutionSucceeded(callback: CallbackFunction): void 1655 1656注册一个回调函数，并在任务执行成功时调用它。需在任务执行前注册，否则会抛异常。 1657 1658**系统能力：** SystemCapability.Utils.Lang 1659 1660**原子化服务API**：从API version 12开始，该接口支持在原子化服务中使用。 1661 1662**参数：** 1663 1664| 参数名 | 类型 | 必填 | 说明 | 1665| ------ | ------ | ---- | ------------------ | 1666| callback | [CallbackFunction](#callbackfunction12) | 是 | 需注册的回调函数。 | 1667 1668**错误码：** 1669 1670以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1671 1672| 错误码ID | 错误信息 | 1673| -------- | ------------------------------ | 1674| 401 | The input parameters are invalid. | 1675| 10200034 | The executed task does not support the registration of listeners. | 1676 1677**示例：** 1678 1679```ts 1680import { taskpool } from '@kit.ArkTS' 1681 1682@Concurrent 1683function delay(args: number): number { 1684 let t: number = Date.now(); 1685 while ((Date.now() - t) < 1000) { 1686 continue; 1687 } 1688 return args; 1689} 1690 1691let task: taskpool.Task = new taskpool.Task(delay, 1); 1692task.onExecutionSucceeded(()=>{ 1693 console.info("taskpool: onExecutionSucceeded") 1694}); 1695taskpool.execute(task).then(()=> { 1696 console.info("taskpool: execute task success") 1697}); 1698``` 1699 1700### isDone<sup>12+</sup> 1701 1702isDone(): boolean 1703 1704检查任务是否已完成。 1705 1706**系统能力：** SystemCapability.Utils.Lang 1707 1708**原子化服务API**：从API version 12开始，该接口支持在原子化服务中使用。 1709 1710**返回值：** 1711 1712| 类型 | 说明 | 1713| ------- | ------------------------------------ | 1714| boolean | 任务执行完成返回true，任务未执行完成返回false。 | 1715 1716**示例：** 1717 1718```ts 1719@Concurrent 1720function inspectStatus(arg: number): number { 1721 // 2s sleep 1722 let t: number = Date.now(); 1723 while (Date.now() - t < 1000) { 1724 continue; 1725 } 1726 return arg + 1; 1727} 1728 1729async function taskpoolCancel(): Promise<void> { 1730 let task: taskpool.Task = new taskpool.Task(inspectStatus, 100); // 100: test number 1731 taskpool.execute(task).then((res: Object)=>{ 1732 console.info("taskpool test result: " + res); 1733 }).catch((err: string) => { 1734 console.error("taskpool test occur error: " + err); 1735 }); 1736 1737 setTimeout(()=>{ 1738 if (!task.isDone()) { 1739 taskpool.cancel(task); 1740 } 1741 }, 3000); // 延时3s，确保任务已执行 1742} 1743 1744taskpoolCancel(); 1745``` 1746 1747## CallbackFunction<sup>12+</sup> 1748 1749type CallbackFunction = () => void 1750 1751注册的回调函数类型。 1752 1753**系统能力：** SystemCapability.Utils.Lang 1754 1755**原子化服务API**：从API version 12开始，该接口支持在原子化服务中使用。 1756 1757 1758## CallbackFunctionWithError<sup>12+</sup> 1759 1760type CallbackFunctionWithError = (e: Error) => void 1761 1762注册带有错误码的回调函数类型。 1763 1764**系统能力：** SystemCapability.Utils.Lang 1765 1766**原子化服务API**：从API version 12开始，该接口支持在原子化服务中使用。 1767 1768**参数：** 1769 1770| 参数名 | 类型 | 必填 | 说明 | 1771| ------ | ------ | ---- | ------------------ | 1772| e | Error | 是 | 错误信息。 | 1773 1774 1775## LongTask<sup>12+</sup> 1776 1777**系统能力：** SystemCapability.Utils.Lang 1778 1779表示长时任务。LongTask继承自[Task](#task)。 1780长时任务不设置执行时间上限，长时间运行不会触发超时异常，但不支持在任务组（TaskGroup）执行和多次执行。 1781执行长时任务的线程一直存在，直到执行完成后调用[terminateTask](#taskpoolterminatetask12)，该线程会在空闲时被回收。 1782 1783**示例：** 1784 1785```ts 1786@Concurrent 1787function printArgs(args: string): string { 1788 console.info("printArgs: " + args); 1789 return args; 1790} 1791 1792let task: taskpool.LongTask = new taskpool.LongTask(printArgs, "this is my first LongTask"); 1793``` 1794 1795 1796## GenericsTask<sup>13+</sup> 1797 1798**系统能力：** SystemCapability.Utils.Lang 1799 1800表示泛型任务。GenericsTask继承自[Task](#task)。 1801相比创建Task，创建GenericsTask可以在编译阶段完成对并发函数的传参和返回值类型的校验，其余行为与Task一致。 1802 1803### constructor<sup>13+</sup> 1804 1805constructor(func: (...args: A) => R | Promise\<R>, ...args: A) 1806 1807GenericsTask的构造函数。 1808 1809**系统能力：** SystemCapability.Utils.Lang 1810 1811**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 1812 1813**参数：** 1814 1815| 参数名 | 类型 | 必填 | 说明 | 1816| ------ | --------- | ---- | -------------------------------------------------------------------- | 1817| func | (...args: A) => R \| Promise\<R> | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 1818| args | A | 否 | 任务执行传入函数的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 1819 1820**错误码：** 1821 1822以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1823 1824| 错误码ID | 错误信息 | 1825| -------- | --------------------------------------- | 1826| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 1827| 10200014 | The function is not marked as concurrent. | 1828 1829**示例：** 1830 1831```ts 1832@Concurrent 1833function printArgs(args: string): string { 1834 console.info("printArgs: " + args); 1835 return args; 1836} 1837 1838@Concurrent 1839function testWithThreeParams(a: number, b: string, c: number): string { 1840 return b; 1841} 1842 1843@Concurrent 1844function testWithArray(args: [number, string]): string { 1845 return "success"; 1846} 1847 1848let task1: taskpool.Task = new taskpool.GenericsTask<[string], string>(printArgs, "this is my first LongTask"); 1849 1850let task2: taskpool.Task = new taskpool.GenericsTask<[number, string, number], string>(testWithThreeParams, 100, "test", 100); 1851 1852let task3: taskpool.Task = new taskpool.GenericsTask<[[number, string]], string>(testWithArray, [100, "test"]); 1853``` 1854 1855### constructor<sup>13+</sup> 1856 1857constructor(name: string, func: (...args: A) => R | Promise\<R>, ...args: A) 1858 1859GenericsTask的构造函数，可以指定任务名称。 1860 1861**系统能力：** SystemCapability.Utils.Lang 1862 1863**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 1864 1865**参数：** 1866 1867| 参数名 | 类型 | 必填 | 说明 | 1868| ------ | -------- | ---- | ------------------------------------------------------------ | 1869| name | string | 是 | 泛型任务名称。 | 1870| func | (...args: A) => R \| Promise\<R> | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 1871| args | A | 否 | 任务执行传入函数的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 1872 1873**错误码：** 1874 1875以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1876 1877| 错误码ID | 错误信息 | 1878| -------- | --------------------------------------- | 1879| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 1880| 10200014 | The function is not marked as concurrent. | 1881 1882**示例：** 1883 1884```ts 1885@Concurrent 1886function printArgs(args: string): string { 1887 console.info("printArgs: " + args); 1888 return args; 1889} 1890 1891let taskName: string = "taskName"; 1892let task: taskpool.Task = new taskpool.GenericsTask<[string], string>(taskName, printArgs, "this is my first Task"); 1893let name: string = task.name; 1894``` 1895 1896## TaskGroup<sup>10+</sup> 1897 1898表示任务组，一次执行一组任务，适用于执行一组有关联的任务。如果所有任务正常执行，异步执行完毕后返回所有任务结果的数组，数组中元素的顺序与[addTask](#addtask10-1)的顺序相同；如果任意任务失败，则会抛出对应异常。如果任务组中存在多个任务失败的情况，则会抛出第一个失败任务的异常。任务组可以多次执行，但执行后不能新增任务。使用[constructor](#constructor10)方法构造TaskGroup。 1899 1900### constructor<sup>10+</sup> 1901 1902constructor() 1903 1904TaskGroup的构造函数。 1905 1906**系统能力：** SystemCapability.Utils.Lang 1907 1908**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1909 1910**示例：** 1911 1912```ts 1913let taskGroup = new taskpool.TaskGroup(); 1914``` 1915 1916### constructor<sup>11+</sup> 1917 1918constructor(name: string) 1919 1920TaskGroup的构造函数，可以指定任务组名称。 1921 1922**系统能力：** SystemCapability.Utils.Lang 1923 1924**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1925 1926**参数：** 1927 1928| 参数名 | 类型 | 必填 | 说明 | 1929| ------ | ------ | ---- | ------------ | 1930| name | string | 是 | 任务组名称。 | 1931 1932**错误码：** 1933 1934以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1935 1936| 错误码ID | 错误信息 | 1937| -------- | -------- | 1938| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1939 1940**示例：** 1941 1942```ts 1943let taskGroupName: string = "groupName"; 1944let taskGroup: taskpool.TaskGroup = new taskpool.TaskGroup(taskGroupName); 1945let name: string = taskGroup.name; 1946``` 1947 1948### addTask<sup>10+</sup> 1949 1950addTask(func: Function, ...args: Object[]): void 1951 1952将待执行的函数添加到任务组中。使用该方法前需要先构造TaskGroup。 1953 1954**系统能力：** SystemCapability.Utils.Lang 1955 1956**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1957 1958**参数：** 1959 1960| 参数名 | 类型 | 必填 | 说明 | 1961| ------ | --------- | ---- | ---------------------------------------------------------------------- | 1962| func | Function | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 1963| args | Object[] | 否 | 任务执行函数所需要的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 1964 1965**错误码：** 1966 1967以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1968 1969| 错误码ID | 错误信息 | 1970| -------- | --------------------------------------- | 1971| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1972| 10200014 | The function is not marked as concurrent. | 1973 1974**示例：** 1975 1976```ts 1977@Concurrent 1978function printArgs(args: number): number { 1979 console.info("printArgs: " + args); 1980 return args; 1981} 1982 1983let taskGroup: taskpool.TaskGroup = new taskpool.TaskGroup(); 1984taskGroup.addTask(printArgs, 100); // 100: test number 1985``` 1986 1987### addTask<sup>10+</sup> 1988 1989addTask(task: Task): void 1990 1991将创建好的任务添加到任务组中。使用该方法前需要先构造TaskGroup。任务组不可以添加其他任务组任务、串行队列任务、有依赖关系的任务、长时任务、周期任务和已执行的任务。 1992 1993**系统能力：** SystemCapability.Utils.Lang 1994 1995**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1996 1997**参数：** 1998 1999| 参数名 | 类型 | 必填 | 说明 | 2000| -------- | --------------------- | ---- | ---------------------------------------- | 2001| task | [Task](#task) | 是 | 需要添加到任务组中的任务。 | 2002 2003**错误码：** 2004 2005以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 2006 2007| 错误码ID | 错误信息 | 2008| -------- | --------------------------------------- | 2009| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 2010| 10200014 | The function is not marked as concurrent. | 2011| 10200051 | The periodic task cannot be executed again. | 2012 2013**示例：** 2014 2015```ts 2016@Concurrent 2017function printArgs(args: number): number { 2018 console.info("printArgs: " + args); 2019 return args; 2020} 2021 2022let taskGroup: taskpool.TaskGroup = new taskpool.TaskGroup(); 2023let task: taskpool.Task = new taskpool.Task(printArgs, 200); // 200: test number 2024taskGroup.addTask(task); 2025``` 2026 2027### 属性 2028 2029**系统能力：** SystemCapability.Utils.Lang 2030 2031**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2032 2033| 名称 | 类型 | 可读 | 可写 | 说明 | 2034| ---- | ------ | ---- | ---- | ---------------------------- | 2035| name<sup>11+</sup> | string | 是 | 是 | 创建任务组时指定的任务组名称。 | 2036 2037## SequenceRunner <sup>11+</sup> 2038 2039表示串行队列的任务，用于执行一组需要串行执行的任务。使用[constructor](#constructor11-3)方法构造SequenceRunner。 2040 2041### constructor<sup>11+</sup> 2042 2043constructor(priority?: Priority) 2044 2045SequenceRunner的构造函数。 2046 2047**系统能力：** SystemCapability.Utils.Lang 2048 2049**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2050 2051**参数：** 2052 2053| 参数名 | 类型 | 必填 | 说明 | 2054| -------- | --------------------- | ---- | ---------------------------------------------------------- | 2055| priority | [Priority](#priority) | 否 | 指定任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 2056 2057**错误码：** 2058 2059以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2060 2061| 错误码ID | 错误信息 | 2062| -------- | -------- | 2063| 401 | Parameter error. Possible causes: 1. Incorrect parameter types; 2. Parameter verification failed. | 2064 2065**示例：** 2066 2067```ts 2068let runner: taskpool.SequenceRunner = new taskpool.SequenceRunner(); 2069``` 2070 2071### constructor<sup>12+</sup> 2072 2073constructor(name: string, priority?: Priority) 2074 2075SequenceRunner的构造函数。构造一个全局串行队列，如果名字相同，将返回同一个串行队列。 2076 2077> **说明：** 2078> 2079> - 底层通过单例模式保证了：创建同名串行队列时，获取到同一个实例。 2080> - 不支持修改串行队列的优先级。 2081 2082**系统能力：** SystemCapability.Utils.Lang 2083 2084**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 2085 2086**参数：** 2087 2088| 参数名 | 类型 | 必填 | 说明 | 2089| -------- | --------------------- | ---- | ---------------------------------------------------------- | 2090| name | string | 是 | 串行队列的名字。 | 2091| priority | [Priority](#priority) | 否 | 指定任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 2092 2093**错误码：** 2094 2095以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2096 2097| 错误码ID | 错误信息 | 2098| -------- | -------- | 2099| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3.Parameter verification failed. | 2100 2101**示例：** 2102 2103```ts 2104let runner:taskpool.SequenceRunner = new taskpool.SequenceRunner("runner1", taskpool.Priority.LOW); 2105``` 2106 2107### execute<sup>11+</sup> 2108 2109execute(task: Task): Promise\<Object> 2110 2111执行串行任务。使用该方法前需要先构造SequenceRunner。串行队列不可以执行任务组任务、其他串行队列任务、有依赖关系的任务和已执行的任务。 2112 2113> **说明：** 2114> 2115> - 不支持加入存在依赖的任务。 2116> - 前面的任务执行失败或取消不影响后续任务执行。 2117 2118**系统能力：** SystemCapability.Utils.Lang 2119 2120**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2121 2122**参数：** 2123 2124| 参数名 | 类型 | 必填 | 说明 | 2125| ------ | ------------- | ---- | -------------------------------- | 2126| task | [Task](#task) | 是 | 需要添加到串行任务队列中的任务。 | 2127 2128**返回值：** 2129 2130| 类型 | 说明 | 2131| ---------------- | --------------------------------- | 2132| Promise\<Object> | Promise对象，返回任务执行的结果。 | 2133 2134**错误码：** 2135 2136以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 2137 2138| 错误码ID | 错误信息 | 2139| -------- | ------------------------------------------- | 2140| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2141| 10200006 | An exception occurred during serialization. | 2142| 10200025 | dependent task not allowed. | 2143| 10200051 | The periodic task cannot be executed again. | 2144 2145**示例：** 2146 2147```ts 2148@Concurrent 2149function additionDelay(delay:number): void { 2150 let start: number = new Date().getTime(); 2151 while (new Date().getTime() - start < delay) { 2152 continue; 2153 } 2154} 2155@Concurrent 2156function waitForRunner(finalString: string): string { 2157 return finalString; 2158} 2159async function seqRunner() 2160{ 2161 let finalString:string = ""; 2162 let task1:taskpool.Task = new taskpool.Task(additionDelay, 3000); 2163 let task2:taskpool.Task = new taskpool.Task(additionDelay, 2000); 2164 let task3:taskpool.Task = new taskpool.Task(additionDelay, 1000); 2165 let task4:taskpool.Task = new taskpool.Task(waitForRunner, finalString); 2166 2167 let runner:taskpool.SequenceRunner = new taskpool.SequenceRunner(); 2168 runner.execute(task1).then(() => { 2169 finalString += 'a'; 2170 console.info("seqrunner: task1 done."); 2171 }); 2172 runner.execute(task2).then(() => { 2173 finalString += 'b'; 2174 console.info("seqrunner: task2 done"); 2175 }); 2176 runner.execute(task3).then(() => { 2177 finalString += 'c'; 2178 console.info("seqrunner: task3 done"); 2179 }); 2180 await runner.execute(task4); 2181 console.info("seqrunner: task4 done, finalString is " + finalString); 2182} 2183``` 2184 2185## State<sup>10+</sup> 2186 2187表示任务（Task）状态的枚举。当任务创建成功后，调用execute，任务进入taskpool等待队列，状态设置为WAITING；任务从等待队列出来进入taskpool工作线程中，任务状态更新为RUNNING；当任务执行完成，返回结果后任务状态重置为WAITING；当主动cancel任务时，将任务状态更新为CANCELED。 2188 2189**系统能力：** SystemCapability.Utils.Lang 2190 2191**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2192 2193| 名称 | 值 | 说明 | 2194| --------- | -------- | ------------- | 2195| WAITING | 1 | 任务正在等待。 | 2196| RUNNING | 2 | 任务正在执行。 | 2197| CANCELED | 3 | 任务已被取消。 | 2198 2199 2200## TaskInfo<sup>10+</sup> 2201 2202任务的内部信息。 2203 2204**系统能力：** SystemCapability.Utils.Lang 2205 2206### 属性 2207 2208**系统能力：** SystemCapability.Utils.Lang 2209 2210| 名称 | 类型 | 可读 | 可写 | 说明 | 2211| -------- | ------------------ | ---- | ---- | ------------------------------------------------------------- | 2212| name<sup>12+</sup> | string | 是 | 否 | 任务的名字。<br/> **原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 2213| taskId | number | 是 | 否 | 任务的ID。<br/> **原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 2214| state | [State](#state10) | 是 | 否 | 任务的状态。<br/> **原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 2215| duration | number | 是 | 否 | 任务执行至当前所用的时间，单位为ms。当返回为0时，表示任务未执行；返回为空时，表示没有任务执行。<br/> **原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 2216 2217## ThreadInfo<sup>10+</sup> 2218 2219工作线程的内部信息。 2220 2221**系统能力：** SystemCapability.Utils.Lang 2222 2223### 属性 2224 2225**系统能力：** SystemCapability.Utils.Lang 2226 2227**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2228 2229| 名称 | 类型 | 可读 | 可写 | 说明 | 2230| -------- | ---------------------- | ---- | ---- | -------------------------------------------------------- | 2231| tid | number | 是 | 否 | 工作线程的标识符。返回为空时，代表没有任务执行。 | 2232| taskIds | number[] | 是 | 否 | 在当前线程上运行的任务id列表。返回为空时，代表没有任务执行。 | 2233| priority | [Priority](#priority) | 是 | 否 | 当前线程的优先级。返回为空时，代表没有任务执行。 | 2234 2235## TaskPoolInfo<sup>10+</sup> 2236 2237任务池的内部信息。 2238 2239**系统能力：** SystemCapability.Utils.Lang 2240 2241### 属性 2242 2243**系统能力：** SystemCapability.Utils.Lang 2244 2245**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2246 2247| 名称 | 类型 | 可读 | 可写 | 说明 | 2248| ------------- | -------------------------------- | ---- | ---- | -------------------- | 2249| threadInfos | [ThreadInfo[]](#threadinfo10) | 是 | 否 | 工作线程的内部信息。 | 2250| taskInfos | [TaskInfo[]](#taskinfo10) | 是 | 否 | 任务的内部信息。 | 2251 2252 2253## 其他说明 2254 2255### 序列化支持类型 2256序列化支持类型包括：目前支持的数据类型有[普通对象](../../arkts-utils/normal-object.md)、[ArrayBuffer对象](../../arkts-utils/arraybuffer-object.md)、[SharedArrayBuffer对象](../../arkts-utils/shared-arraybuffer-object.md)、[Transferable对象（NativeBinding对象）](../../arkts-utils/transferabled-object.md)、[Sendable对象](../../arkts-utils/arkts-sendable.md)五种。 2257 2258### 简单使用 2259 2260**示例一** 2261 2262```ts 2263// 支持普通函数、引用入参传递 2264@Concurrent 2265function printArgs(args: string): string { 2266 console.info("func: " + args); 2267 return args; 2268} 2269 2270async function taskpoolExecute(): Promise<void> { 2271 // taskpool.execute(task) 2272 let task: taskpool.Task = new taskpool.Task(printArgs, "create task, then execute"); 2273 console.info("taskpool.execute(task) result: " + await taskpool.execute(task)); 2274 // taskpool.execute(function) 2275 console.info("taskpool.execute(function) result: " + await taskpool.execute(printArgs, "execute task by func")); 2276} 2277 2278taskpoolExecute(); 2279``` 2280 2281**示例二** 2282 2283```ts 2284// b.ets 2285export let c: string = "hello"; 2286``` 2287<!--code_no_check--> 2288```ts 2289// 引用import变量 2290// a.ets(与b.ets位于同一目录中) 2291import { c } from "./b"; 2292 2293@Concurrent 2294function printArgs(a: string): string { 2295 console.info(a); 2296 console.info(c); 2297 return a; 2298} 2299 2300async function taskpoolExecute(): Promise<void> { 2301 // taskpool.execute(task) 2302 let task: taskpool.Task = new taskpool.Task(printArgs, "create task, then execute"); 2303 console.info("taskpool.execute(task) result: " + await taskpool.execute(task)); 2304 2305 // taskpool.execute(function) 2306 console.info("taskpool.execute(function) result: " + await taskpool.execute(printArgs, "execute task by func")); 2307} 2308 2309taskpoolExecute(); 2310``` 2311 2312**示例三** 2313 2314```ts 2315// 支持async函数 2316@Concurrent 2317async function delayExecute(): Promise<Object> { 2318 let ret = await Promise.all<Object>([ 2319 new Promise<Object>(resolve => setTimeout(resolve, 1000, "resolved")) 2320 ]); 2321 return ret; 2322} 2323 2324async function taskpoolExecute(): Promise<void> { 2325 taskpool.execute(delayExecute).then((result: Object) => { 2326 console.info("taskPoolTest task result: " + result); 2327 }).catch((err: string) => { 2328 console.error("taskpool test occur error: " + err); 2329 }); 2330} 2331 2332taskpoolExecute(); 2333``` 2334 2335**示例四** 2336 2337```ts 2338// c.ets 2339import { taskpool } from '@kit.ArkTS'; 2340 2341@Concurrent 2342function strSort(inPutArr: Array<string>): Array<string> { 2343 let newArr = inPutArr.sort(); 2344 return newArr; 2345} 2346 2347export async function func1(): Promise<void> { 2348 console.info("taskpoolTest start"); 2349 let strArray: Array<string> = ['c test string', 'b test string', 'a test string']; 2350 let task: taskpool.Task = new taskpool.Task(strSort, strArray); 2351 console.info("func1 result:" + await taskpool.execute(task)); 2352} 2353 2354export async function func2(): Promise<void> { 2355 console.info("taskpoolTest2 start"); 2356 let strArray: Array<string> = ['c test string', 'b test string', 'a test string']; 2357 taskpool.execute(strSort, strArray).then((result: Object) => { 2358 console.info("func2 result: " + result); 2359 }).catch((err: string) => { 2360 console.error("taskpool test occur error: " + err); 2361 }); 2362} 2363``` 2364<!--code_no_check--> 2365```ts 2366// index.ets 2367import { func1, func2 } from "./c"; 2368 2369func1(); 2370func2(); 2371``` 2372 2373**示例五** 2374 2375```ts 2376// 任务取消成功 2377@Concurrent 2378function inspectStatus(arg: number): number { 2379 // 第一次检查任务是否已经取消并作出响应 2380 if (taskpool.Task.isCanceled()) { 2381 console.info("task has been canceled before 2s sleep."); 2382 return arg + 2; 2383 } 2384 // 2s sleep 2385 let t: number = Date.now(); 2386 while (Date.now() - t < 2000) { 2387 continue; 2388 } 2389 // 第二次检查任务是否已经取消并作出响应 2390 if (taskpool.Task.isCanceled()) { 2391 console.info("task has been canceled after 2s sleep."); 2392 return arg + 3; 2393 } 2394 return arg + 1; 2395} 2396 2397async function taskpoolCancel(): Promise<void> { 2398 let task: taskpool.Task = new taskpool.Task(inspectStatus, 100); // 100: test number 2399 taskpool.execute(task).then((res: Object) => { 2400 console.info("taskpool test result: " + res); 2401 }).catch((err: string) => { 2402 console.error("taskpool test occur error: " + err); 2403 }); 2404 // 1s后取消task 2405 setTimeout(() => { 2406 try { 2407 taskpool.cancel(task); 2408 } catch (e) { 2409 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 2410 } 2411 }, 1000); 2412} 2413 2414taskpoolCancel(); 2415``` 2416 2417**示例六** 2418 2419```ts 2420// 已执行的任务取消失败 2421@Concurrent 2422function inspectStatus(arg: number): number { 2423 // 第一次检查任务是否已经取消并作出响应 2424 if (taskpool.Task.isCanceled()) { 2425 return arg + 2; 2426 } 2427 // 延时2s 2428 let t: number = Date.now(); 2429 while (Date.now() - t < 500) { 2430 continue; 2431 } 2432 // 第二次检查任务是否已经取消并作出响应 2433 if (taskpool.Task.isCanceled()) { 2434 return arg + 3; 2435 } 2436 return arg + 1; 2437} 2438 2439async function taskpoolCancel(): Promise<void> { 2440 let task: taskpool.Task = new taskpool.Task(inspectStatus, 100); // 100: test number 2441 taskpool.execute(task).then((res: Object) => { 2442 console.info("taskpool test result: " + res); 2443 }).catch((err: string) => { 2444 console.error("taskpool test occur error: " + err); 2445 }); 2446 2447 setTimeout(() => { 2448 try { 2449 taskpool.cancel(task); // 任务已执行,取消失败 2450 } catch (e) { 2451 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 2452 } 2453 }, 3000); // 延时3s，确保任务已执行 2454} 2455 2456taskpoolCancel(); 2457``` 2458 2459**示例七** 2460 2461```ts 2462// 待执行的任务组取消成功 2463@Concurrent 2464function printArgs(args: number): number { 2465 let t: number = Date.now(); 2466 while (Date.now() - t < 1000) { 2467 continue; 2468 } 2469 console.info("printArgs: " + args); 2470 return args; 2471} 2472 2473async function taskpoolGroupCancelTest(): Promise<void> { 2474 let taskGroup1: taskpool.TaskGroup = new taskpool.TaskGroup(); 2475 taskGroup1.addTask(printArgs, 10); // 10: test number 2476 taskGroup1.addTask(printArgs, 20); // 20: test number 2477 taskGroup1.addTask(printArgs, 30); // 30: test number 2478 let taskGroup2: taskpool.TaskGroup = new taskpool.TaskGroup(); 2479 let task1: taskpool.Task = new taskpool.Task(printArgs, 100); // 100: test number 2480 let task2: taskpool.Task = new taskpool.Task(printArgs, 200); // 200: test number 2481 let task3: taskpool.Task = new taskpool.Task(printArgs, 300); // 300: test number 2482 taskGroup2.addTask(task1); 2483 taskGroup2.addTask(task2); 2484 taskGroup2.addTask(task3); 2485 taskpool.execute(taskGroup1).then((res: Array<Object>) => { 2486 console.info("taskpool execute res is:" + res); 2487 }).catch((e: string) => { 2488 console.error("taskpool execute error is:" + e); 2489 }); 2490 taskpool.execute(taskGroup2).then((res: Array<Object>) => { 2491 console.info("taskpool execute res is:" + res); 2492 }).catch((e: string) => { 2493 console.error("taskpool execute error is:" + e); 2494 }); 2495 2496 try { 2497 taskpool.cancel(taskGroup2); 2498 } catch (e) { 2499 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 2500 } 2501} 2502 2503taskpoolGroupCancelTest() 2504``` 2505 2506**示例八** 2507 2508```ts 2509// 分别创建执行100个高、中、低优先级的任务，查看其各项信息 2510@Concurrent 2511function delay(): void { 2512 let start: number = new Date().getTime(); 2513 while (new Date().getTime() - start < 500) { 2514 continue; 2515 } 2516} 2517 2518let highCount: number = 0; 2519let mediumCount: number = 0; 2520let lowCount: number = 0; 2521let allCount: number = 100; 2522for (let i = 0; i < allCount; i++) { 2523 let task1: taskpool.Task = new taskpool.Task(delay); 2524 let task2: taskpool.Task = new taskpool.Task(delay); 2525 let task3: taskpool.Task = new taskpool.Task(delay); 2526 taskpool.execute(task1, taskpool.Priority.LOW).then(() => { 2527 lowCount++; 2528 }).catch((e: string) => { 2529 console.error("low task error: " + e); 2530 }) 2531 taskpool.execute(task2, taskpool.Priority.MEDIUM).then(() => { 2532 mediumCount++; 2533 }).catch((e: string) => { 2534 console.error("medium task error: " + e); 2535 }) 2536 taskpool.execute(task3, taskpool.Priority.HIGH).then(() => { 2537 highCount++; 2538 }).catch((e: string) => { 2539 console.error("high task error: " + e); 2540 }) 2541} 2542let start: number = new Date().getTime(); 2543while (new Date().getTime() - start < 1000) { 2544 continue; 2545} 2546let taskpoolInfo: taskpool.TaskPoolInfo = taskpool.getTaskPoolInfo(); 2547let tid: number = 0; 2548let taskIds: Array<number> = []; 2549let priority: number = 0; 2550let taskId: number = 0; 2551let state: number = 0; 2552let duration: number = 0; 2553let name: string = ""; 2554let threadIS = Array.from(taskpoolInfo.threadInfos) 2555for (let threadInfo of threadIS) { 2556 tid = threadInfo.tid; 2557 if (threadInfo.taskIds != undefined && threadInfo.priority != undefined) { 2558 taskIds.length = threadInfo.taskIds.length; 2559 priority = threadInfo.priority; 2560 } 2561 console.info("taskpool---tid is:" + tid + ", taskIds is:" + taskIds + ", priority is:" + priority); 2562} 2563let taskIS = Array.from(taskpoolInfo.taskInfos) 2564for (let taskInfo of taskIS) { 2565 taskId = taskInfo.taskId; 2566 state = taskInfo.state; 2567 if (taskInfo.duration != undefined) { 2568 duration = taskInfo.duration; 2569 name = taskInfo.name; 2570 } 2571 console.info("taskpool---taskId is:" + taskId + ", state is:" + state + ", duration is:" + duration + ", name is:" + name); 2572} 2573```