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| e | Error | 是 | 错误信息。 | 1772 1773 1774## LongTask<sup>12+</sup> 1775 1776**系统能力：** SystemCapability.Utils.Lang 1777 1778表示长时任务。LongTask继承自[Task](#task)。 1779长时任务不设置执行时间上限，长时间运行不会触发超时异常，但不支持在任务组（TaskGroup）执行和多次执行。 1780执行长时任务的线程一直存在，直到执行完成后调用[terminateTask](#taskpoolterminatetask12)，该线程会在空闲时被回收。 1781 1782**示例：** 1783 1784```ts 1785@Concurrent 1786function printArgs(args: string): string { 1787 console.info("printArgs: " + args); 1788 return args; 1789} 1790 1791let task: taskpool.LongTask = new taskpool.LongTask(printArgs, "this is my first LongTask"); 1792``` 1793 1794 1795## GenericsTask<sup>13+</sup> 1796 1797**系统能力：** SystemCapability.Utils.Lang 1798 1799表示泛型任务。GenericsTask继承自[Task](#task)。 1800相比创建Task，创建GenericsTask可以在编译阶段完成对并发函数的传参和返回值类型的校验，其余行为与Task一致。 1801 1802### constructor<sup>13+</sup> 1803 1804constructor(func: (...args: A) => R | Promise\<R>, ...args: A) 1805 1806GenericsTask的构造函数。 1807 1808**系统能力：** SystemCapability.Utils.Lang 1809 1810**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 1811 1812**参数：** 1813 1814| 参数名 | 类型 | 必填 | 说明 | 1815| ------ | --------- | ---- | -------------------------------------------------------------------- | 1816| func | (...args: A) => R \| Promise\<R> | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 1817| args | A | 否 | 任务执行传入函数的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 1818 1819**错误码：** 1820 1821以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1822 1823| 错误码ID | 错误信息 | 1824| -------- | --------------------------------------- | 1825| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 1826| 10200014 | The function is not marked as concurrent. | 1827 1828**示例：** 1829 1830```ts 1831@Concurrent 1832function printArgs(args: string): string { 1833 console.info("printArgs: " + args); 1834 return args; 1835} 1836 1837@Concurrent 1838function testWithThreeParams(a: number, b: string, c: number): string { 1839 return b; 1840} 1841 1842@Concurrent 1843function testWithArray(args: [number, string]): string { 1844 return "success"; 1845} 1846 1847let task1: taskpool.Task = new taskpool.GenericsTask<[string], string>(printArgs, "this is my first LongTask"); 1848 1849let task2: taskpool.Task = new taskpool.GenericsTask<[number, string, number], string>(testWithThreeParams, 100, "test", 100); 1850 1851let task3: taskpool.Task = new taskpool.GenericsTask<[[number, string]], string>(testWithArray, [100, "test"]); 1852``` 1853 1854### constructor<sup>13+</sup> 1855 1856constructor(name: string, func: (...args: A) => R | Promise\<R>, ...args: A) 1857 1858GenericsTask的构造函数，可以指定任务名称。 1859 1860**系统能力：** SystemCapability.Utils.Lang 1861 1862**原子化服务API**：从API version 13 开始，该接口支持在原子化服务中使用。 1863 1864**参数：** 1865 1866| 参数名 | 类型 | 必填 | 说明 | 1867| ------ | -------- | ---- | ------------------------------------------------------------ | 1868| name | string | 是 | 泛型任务名称。 | 1869| func | (...args: A) => R \| Promise\<R> | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 1870| args | A | 否 | 任务执行传入函数的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 1871 1872**错误码：** 1873 1874以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1875 1876| 错误码ID | 错误信息 | 1877| -------- | --------------------------------------- | 1878| 401 | Parameter error. Possible causes: 1.Incorrect parameter types; 2.Parameter verification failed. | 1879| 10200014 | The function is not marked as concurrent. | 1880 1881**示例：** 1882 1883```ts 1884@Concurrent 1885function printArgs(args: string): string { 1886 console.info("printArgs: " + args); 1887 return args; 1888} 1889 1890let taskName: string = "taskName"; 1891let task: taskpool.Task = new taskpool.GenericsTask<[string], string>(taskName, printArgs, "this is my first Task"); 1892let name: string = task.name; 1893``` 1894 1895## TaskGroup<sup>10+</sup> 1896 1897表示任务组，一次执行一组任务，适用于执行一组有关联的任务。如果所有任务正常执行，异步执行完毕后返回所有任务结果的数组，数组中元素的顺序与[addTask](#addtask10-1)的顺序相同；如果任意任务失败，则会抛出对应异常。如果任务组中存在多个任务失败的情况，则会抛出第一个失败任务的异常。任务组可以多次执行，但执行后不能新增任务。使用[constructor](#constructor10)方法构造TaskGroup。 1898 1899### constructor<sup>10+</sup> 1900 1901constructor() 1902 1903TaskGroup的构造函数。 1904 1905**系统能力：** SystemCapability.Utils.Lang 1906 1907**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1908 1909**示例：** 1910 1911```ts 1912let taskGroup = new taskpool.TaskGroup(); 1913``` 1914 1915### constructor<sup>11+</sup> 1916 1917constructor(name: string) 1918 1919TaskGroup的构造函数，可以指定任务组名称。 1920 1921**系统能力：** SystemCapability.Utils.Lang 1922 1923**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1924 1925**参数：** 1926 1927| 参数名 | 类型 | 必填 | 说明 | 1928| ------ | ------ | ---- | ------------ | 1929| name | string | 是 | 任务组名称。 | 1930 1931**错误码：** 1932 1933以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 1934 1935| 错误码ID | 错误信息 | 1936| -------- | -------- | 1937| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1938 1939**示例：** 1940 1941```ts 1942let taskGroupName: string = "groupName"; 1943let taskGroup: taskpool.TaskGroup = new taskpool.TaskGroup(taskGroupName); 1944let name: string = taskGroup.name; 1945``` 1946 1947### addTask<sup>10+</sup> 1948 1949addTask(func: Function, ...args: Object[]): void 1950 1951将待执行的函数添加到任务组中。使用该方法前需要先构造TaskGroup。 1952 1953**系统能力：** SystemCapability.Utils.Lang 1954 1955**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1956 1957**参数：** 1958 1959| 参数名 | 类型 | 必填 | 说明 | 1960| ------ | --------- | ---- | ---------------------------------------------------------------------- | 1961| func | Function | 是 | 执行的逻辑需要传入函数，必须使用[@Concurrent装饰器](../../arkts-utils/taskpool-introduction.md#concurrent装饰器)装饰，支持的函数返回值类型请查[序列化支持类型](#序列化支持类型)。 | 1962| args | Object[] | 否 | 任务执行函数所需要的入参，支持的参数类型请查[序列化支持类型](#序列化支持类型)。默认值为undefined。 | 1963 1964**错误码：** 1965 1966以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 1967 1968| 错误码ID | 错误信息 | 1969| -------- | --------------------------------------- | 1970| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 1971| 10200014 | The function is not marked as concurrent. | 1972 1973**示例：** 1974 1975```ts 1976@Concurrent 1977function printArgs(args: number): number { 1978 console.info("printArgs: " + args); 1979 return args; 1980} 1981 1982let taskGroup: taskpool.TaskGroup = new taskpool.TaskGroup(); 1983taskGroup.addTask(printArgs, 100); // 100: test number 1984``` 1985 1986### addTask<sup>10+</sup> 1987 1988addTask(task: Task): void 1989 1990将创建好的任务添加到任务组中。使用该方法前需要先构造TaskGroup。任务组不可以添加其他任务组任务、串行队列任务、有依赖关系的任务、长时任务、周期任务和已执行的任务。 1991 1992**系统能力：** SystemCapability.Utils.Lang 1993 1994**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 1995 1996**参数：** 1997 1998| 参数名 | 类型 | 必填 | 说明 | 1999| -------- | --------------------- | ---- | ---------------------------------------- | 2000| task | [Task](#task) | 是 | 需要添加到任务组中的任务。 | 2001 2002**错误码：** 2003 2004以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 2005 2006| 错误码ID | 错误信息 | 2007| -------- | --------------------------------------- | 2008| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types; 3. Parameter verification failed. | 2009| 10200014 | The function is not marked as concurrent. | 2010| 10200051 | The periodic task cannot be executed again. | 2011 2012**示例：** 2013 2014```ts 2015@Concurrent 2016function printArgs(args: number): number { 2017 console.info("printArgs: " + args); 2018 return args; 2019} 2020 2021let taskGroup: taskpool.TaskGroup = new taskpool.TaskGroup(); 2022let task: taskpool.Task = new taskpool.Task(printArgs, 200); // 200: test number 2023taskGroup.addTask(task); 2024``` 2025 2026### 属性 2027 2028**系统能力：** SystemCapability.Utils.Lang 2029 2030**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2031 2032| 名称 | 类型 | 可读 | 可写 | 说明 | 2033| ---- | ------ | ---- | ---- | ---------------------------- | 2034| name<sup>11+</sup> | string | 是 | 是 | 创建任务组时指定的任务组名称。 | 2035 2036## SequenceRunner <sup>11+</sup> 2037 2038表示串行队列的任务，用于执行一组需要串行执行的任务。使用[constructor](#constructor11-3)方法构造SequenceRunner。 2039 2040### constructor<sup>11+</sup> 2041 2042constructor(priority?: Priority) 2043 2044SequenceRunner的构造函数。 2045 2046**系统能力：** SystemCapability.Utils.Lang 2047 2048**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2049 2050**参数：** 2051 2052| 参数名 | 类型 | 必填 | 说明 | 2053| -------- | --------------------- | ---- | ---------------------------------------------------------- | 2054| priority | [Priority](#priority) | 否 | 指定任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 2055 2056**错误码：** 2057 2058以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2059 2060| 错误码ID | 错误信息 | 2061| -------- | -------- | 2062| 401 | Parameter error. Possible causes: 1. Incorrect parameter types; 2. Parameter verification failed. | 2063 2064**示例：** 2065 2066```ts 2067let runner: taskpool.SequenceRunner = new taskpool.SequenceRunner(); 2068``` 2069 2070### constructor<sup>12+</sup> 2071 2072constructor(name: string, priority?: Priority) 2073 2074SequenceRunner的构造函数。构造一个全局串行队列，如果名字相同，将返回同一个串行队列。 2075 2076> **说明：** 2077> 2078> - 底层通过单例模式保证了：创建同名串行队列时，获取到同一个实例。 2079> - 不支持修改串行队列的优先级。 2080 2081**系统能力：** SystemCapability.Utils.Lang 2082 2083**原子化服务API**：从API version 12 开始，该接口支持在原子化服务中使用。 2084 2085**参数：** 2086 2087| 参数名 | 类型 | 必填 | 说明 | 2088| -------- | --------------------- | ---- | ---------------------------------------------------------- | 2089| name | string | 是 | 串行队列的名字。 | 2090| priority | [Priority](#priority) | 否 | 指定任务的优先级，该参数默认值为taskpool.Priority.MEDIUM。 | 2091 2092**错误码：** 2093 2094以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)。 2095 2096| 错误码ID | 错误信息 | 2097| -------- | -------- | 2098| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified. 2. Incorrect parameter types. 3.Parameter verification failed. | 2099 2100**示例：** 2101 2102```ts 2103let runner:taskpool.SequenceRunner = new taskpool.SequenceRunner("runner1", taskpool.Priority.LOW); 2104``` 2105 2106### execute<sup>11+</sup> 2107 2108execute(task: Task): Promise\<Object> 2109 2110执行串行任务。使用该方法前需要先构造SequenceRunner。串行队列不可以执行任务组任务、其他串行队列任务、有依赖关系的任务和已执行的任务。 2111 2112> **说明：** 2113> 2114> - 不支持加入存在依赖的任务。 2115> - 前面的任务执行失败或取消不影响后续任务执行。 2116 2117**系统能力：** SystemCapability.Utils.Lang 2118 2119**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2120 2121**参数：** 2122 2123| 参数名 | 类型 | 必填 | 说明 | 2124| ------ | ------------- | ---- | -------------------------------- | 2125| task | [Task](#task) | 是 | 需要添加到串行任务队列中的任务。 | 2126 2127**返回值：** 2128 2129| 类型 | 说明 | 2130| ---------------- | --------------------------------- | 2131| Promise\<Object> | Promise对象，返回任务执行的结果。 | 2132 2133**错误码：** 2134 2135以下错误码的详细介绍请参见[通用错误码](../errorcode-universal.md)和[语言基础类库错误码](errorcode-utils.md)。 2136 2137| 错误码ID | 错误信息 | 2138| -------- | ------------------------------------------- | 2139| 401 | Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types. | 2140| 10200006 | An exception occurred during serialization. | 2141| 10200025 | dependent task not allowed. | 2142| 10200051 | The periodic task cannot be executed again. | 2143 2144**示例：** 2145 2146```ts 2147@Concurrent 2148function additionDelay(delay:number): void { 2149 let start: number = new Date().getTime(); 2150 while (new Date().getTime() - start < delay) { 2151 continue; 2152 } 2153} 2154@Concurrent 2155function waitForRunner(finalString: string): string { 2156 return finalString; 2157} 2158async function seqRunner() 2159{ 2160 let finalString:string = ""; 2161 let task1:taskpool.Task = new taskpool.Task(additionDelay, 3000); 2162 let task2:taskpool.Task = new taskpool.Task(additionDelay, 2000); 2163 let task3:taskpool.Task = new taskpool.Task(additionDelay, 1000); 2164 let task4:taskpool.Task = new taskpool.Task(waitForRunner, finalString); 2165 2166 let runner:taskpool.SequenceRunner = new taskpool.SequenceRunner(); 2167 runner.execute(task1).then(() => { 2168 finalString += 'a'; 2169 console.info("seqrunner: task1 done."); 2170 }); 2171 runner.execute(task2).then(() => { 2172 finalString += 'b'; 2173 console.info("seqrunner: task2 done"); 2174 }); 2175 runner.execute(task3).then(() => { 2176 finalString += 'c'; 2177 console.info("seqrunner: task3 done"); 2178 }); 2179 await runner.execute(task4); 2180 console.info("seqrunner: task4 done, finalString is " + finalString); 2181} 2182``` 2183 2184## State<sup>10+</sup> 2185 2186表示任务（Task）状态的枚举。当任务创建成功后，调用execute，任务进入taskpool等待队列，状态设置为WAITING；任务从等待队列出来进入taskpool工作线程中，任务状态更新为RUNNING；当任务执行完成，返回结果后任务状态重置为WAITING；当主动cancel任务时，将任务状态更新为CANCELED。 2187 2188**系统能力：** SystemCapability.Utils.Lang 2189 2190**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2191 2192| 名称 | 值 | 说明 | 2193| --------- | -------- | ------------- | 2194| WAITING | 1 | 任务正在等待。 | 2195| RUNNING | 2 | 任务正在执行。 | 2196| CANCELED | 3 | 任务已被取消。 | 2197 2198 2199## TaskInfo<sup>10+</sup> 2200 2201任务的内部信息。 2202 2203**系统能力：** SystemCapability.Utils.Lang 2204 2205### 属性 2206 2207**系统能力：** SystemCapability.Utils.Lang 2208 2209| 名称 | 类型 | 可读 | 可写 | 说明 | 2210| -------- | ------------------ | ---- | ---- | ------------------------------------------------------------- | 2211| name<sup>12+</sup> | string | 是 | 否 | 任务的名字。<br/> **原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 | 2212| taskId | number | 是 | 否 | 任务的ID。<br/> **原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 2213| state | [State](#state10) | 是 | 否 | 任务的状态。<br/> **原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 2214| duration | number | 是 | 否 | 任务执行至当前所用的时间，单位为ms。当返回为0时，表示任务未执行；返回为空时，表示没有任务执行。<br/> **原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 | 2215 2216## ThreadInfo<sup>10+</sup> 2217 2218工作线程的内部信息。 2219 2220**系统能力：** SystemCapability.Utils.Lang 2221 2222### 属性 2223 2224**系统能力：** SystemCapability.Utils.Lang 2225 2226**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2227 2228| 名称 | 类型 | 可读 | 可写 | 说明 | 2229| -------- | ---------------------- | ---- | ---- | -------------------------------------------------------- | 2230| tid | number | 是 | 否 | 工作线程的标识符。返回为空时，代表没有任务执行。 | 2231| taskIds | number[] | 是 | 否 | 在当前线程上运行的任务id列表。返回为空时，代表没有任务执行。 | 2232| priority | [Priority](#priority) | 是 | 否 | 当前线程的优先级。返回为空时，代表没有任务执行。 | 2233 2234## TaskPoolInfo<sup>10+</sup> 2235 2236任务池的内部信息。 2237 2238**系统能力：** SystemCapability.Utils.Lang 2239 2240### 属性 2241 2242**系统能力：** SystemCapability.Utils.Lang 2243 2244**原子化服务API**：从API version 11 开始，该接口支持在原子化服务中使用。 2245 2246| 名称 | 类型 | 可读 | 可写 | 说明 | 2247| ------------- | -------------------------------- | ---- | ---- | -------------------- | 2248| threadInfos | [ThreadInfo[]](#threadinfo10) | 是 | 否 | 工作线程的内部信息。 | 2249| taskInfos | [TaskInfo[]](#taskinfo10) | 是 | 否 | 任务的内部信息。 | 2250 2251 2252## 其他说明 2253 2254### 序列化支持类型 2255序列化支持类型包括：目前支持的数据类型有[普通对象](../../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)五种。 2256 2257### 简单使用 2258 2259**示例一** 2260 2261```ts 2262// 支持普通函数、引用入参传递 2263@Concurrent 2264function printArgs(args: string): string { 2265 console.info("func: " + args); 2266 return args; 2267} 2268 2269async function taskpoolExecute(): Promise<void> { 2270 // taskpool.execute(task) 2271 let task: taskpool.Task = new taskpool.Task(printArgs, "create task, then execute"); 2272 console.info("taskpool.execute(task) result: " + await taskpool.execute(task)); 2273 // taskpool.execute(function) 2274 console.info("taskpool.execute(function) result: " + await taskpool.execute(printArgs, "execute task by func")); 2275} 2276 2277taskpoolExecute(); 2278``` 2279 2280**示例二** 2281 2282```ts 2283// b.ets 2284export let c: string = "hello"; 2285``` 2286<!--code_no_check--> 2287```ts 2288// 引用import变量 2289// a.ets(与b.ets位于同一目录中) 2290import { c } from "./b"; 2291 2292@Concurrent 2293function printArgs(a: string): string { 2294 console.info(a); 2295 console.info(c); 2296 return a; 2297} 2298 2299async function taskpoolExecute(): Promise<void> { 2300 // taskpool.execute(task) 2301 let task: taskpool.Task = new taskpool.Task(printArgs, "create task, then execute"); 2302 console.info("taskpool.execute(task) result: " + await taskpool.execute(task)); 2303 2304 // taskpool.execute(function) 2305 console.info("taskpool.execute(function) result: " + await taskpool.execute(printArgs, "execute task by func")); 2306} 2307 2308taskpoolExecute(); 2309``` 2310 2311**示例三** 2312 2313```ts 2314// 支持async函数 2315@Concurrent 2316async function delayExecute(): Promise<Object> { 2317 let ret = await Promise.all<Object>([ 2318 new Promise<Object>(resolve => setTimeout(resolve, 1000, "resolved")) 2319 ]); 2320 return ret; 2321} 2322 2323async function taskpoolExecute(): Promise<void> { 2324 taskpool.execute(delayExecute).then((result: Object) => { 2325 console.info("taskPoolTest task result: " + result); 2326 }).catch((err: string) => { 2327 console.error("taskpool test occur error: " + err); 2328 }); 2329} 2330 2331taskpoolExecute(); 2332``` 2333 2334**示例四** 2335 2336```ts 2337// c.ets 2338import { taskpool } from '@kit.ArkTS'; 2339 2340@Concurrent 2341function strSort(inPutArr: Array<string>): Array<string> { 2342 let newArr = inPutArr.sort(); 2343 return newArr; 2344} 2345 2346export async function func1(): Promise<void> { 2347 console.info("taskpoolTest start"); 2348 let strArray: Array<string> = ['c test string', 'b test string', 'a test string']; 2349 let task: taskpool.Task = new taskpool.Task(strSort, strArray); 2350 console.info("func1 result:" + await taskpool.execute(task)); 2351} 2352 2353export async function func2(): Promise<void> { 2354 console.info("taskpoolTest2 start"); 2355 let strArray: Array<string> = ['c test string', 'b test string', 'a test string']; 2356 taskpool.execute(strSort, strArray).then((result: Object) => { 2357 console.info("func2 result: " + result); 2358 }).catch((err: string) => { 2359 console.error("taskpool test occur error: " + err); 2360 }); 2361} 2362``` 2363<!--code_no_check--> 2364```ts 2365// index.ets 2366import { func1, func2 } from "./c"; 2367 2368func1(); 2369func2(); 2370``` 2371 2372**示例五** 2373 2374```ts 2375// 任务取消成功 2376@Concurrent 2377function inspectStatus(arg: number): number { 2378 // 第一次检查任务是否已经取消并作出响应 2379 if (taskpool.Task.isCanceled()) { 2380 console.info("task has been canceled before 2s sleep."); 2381 return arg + 2; 2382 } 2383 // 2s sleep 2384 let t: number = Date.now(); 2385 while (Date.now() - t < 2000) { 2386 continue; 2387 } 2388 // 第二次检查任务是否已经取消并作出响应 2389 if (taskpool.Task.isCanceled()) { 2390 console.info("task has been canceled after 2s sleep."); 2391 return arg + 3; 2392 } 2393 return arg + 1; 2394} 2395 2396async function taskpoolCancel(): Promise<void> { 2397 let task: taskpool.Task = new taskpool.Task(inspectStatus, 100); // 100: test number 2398 taskpool.execute(task).then((res: Object) => { 2399 console.info("taskpool test result: " + res); 2400 }).catch((err: string) => { 2401 console.error("taskpool test occur error: " + err); 2402 }); 2403 // 1s后取消task 2404 setTimeout(() => { 2405 try { 2406 taskpool.cancel(task); 2407 } catch (e) { 2408 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 2409 } 2410 }, 1000); 2411} 2412 2413taskpoolCancel(); 2414``` 2415 2416**示例六** 2417 2418```ts 2419// 已执行的任务取消失败 2420@Concurrent 2421function inspectStatus(arg: number): number { 2422 // 第一次检查任务是否已经取消并作出响应 2423 if (taskpool.Task.isCanceled()) { 2424 return arg + 2; 2425 } 2426 // 延时2s 2427 let t: number = Date.now(); 2428 while (Date.now() - t < 500) { 2429 continue; 2430 } 2431 // 第二次检查任务是否已经取消并作出响应 2432 if (taskpool.Task.isCanceled()) { 2433 return arg + 3; 2434 } 2435 return arg + 1; 2436} 2437 2438async function taskpoolCancel(): Promise<void> { 2439 let task: taskpool.Task = new taskpool.Task(inspectStatus, 100); // 100: test number 2440 taskpool.execute(task).then((res: Object) => { 2441 console.info("taskpool test result: " + res); 2442 }).catch((err: string) => { 2443 console.error("taskpool test occur error: " + err); 2444 }); 2445 2446 setTimeout(() => { 2447 try { 2448 taskpool.cancel(task); // 任务已执行,取消失败 2449 } catch (e) { 2450 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 2451 } 2452 }, 3000); // 延时3s，确保任务已执行 2453} 2454 2455taskpoolCancel(); 2456``` 2457 2458**示例七** 2459 2460```ts 2461// 待执行的任务组取消成功 2462@Concurrent 2463function printArgs(args: number): number { 2464 let t: number = Date.now(); 2465 while (Date.now() - t < 1000) { 2466 continue; 2467 } 2468 console.info("printArgs: " + args); 2469 return args; 2470} 2471 2472async function taskpoolGroupCancelTest(): Promise<void> { 2473 let taskGroup1: taskpool.TaskGroup = new taskpool.TaskGroup(); 2474 taskGroup1.addTask(printArgs, 10); // 10: test number 2475 taskGroup1.addTask(printArgs, 20); // 20: test number 2476 taskGroup1.addTask(printArgs, 30); // 30: test number 2477 let taskGroup2: taskpool.TaskGroup = new taskpool.TaskGroup(); 2478 let task1: taskpool.Task = new taskpool.Task(printArgs, 100); // 100: test number 2479 let task2: taskpool.Task = new taskpool.Task(printArgs, 200); // 200: test number 2480 let task3: taskpool.Task = new taskpool.Task(printArgs, 300); // 300: test number 2481 taskGroup2.addTask(task1); 2482 taskGroup2.addTask(task2); 2483 taskGroup2.addTask(task3); 2484 taskpool.execute(taskGroup1).then((res: Array<Object>) => { 2485 console.info("taskpool execute res is:" + res); 2486 }).catch((e: string) => { 2487 console.error("taskpool execute error is:" + e); 2488 }); 2489 taskpool.execute(taskGroup2).then((res: Array<Object>) => { 2490 console.info("taskpool execute res is:" + res); 2491 }).catch((e: string) => { 2492 console.error("taskpool execute error is:" + e); 2493 }); 2494 2495 try { 2496 taskpool.cancel(taskGroup2); 2497 } catch (e) { 2498 console.error(`taskpool: cancel error code: ${e.code}, info: ${e.message}`); 2499 } 2500} 2501 2502taskpoolGroupCancelTest() 2503``` 2504 2505**示例八** 2506 2507```ts 2508// 分别创建执行100个高、中、低优先级的任务，查看其各项信息 2509@Concurrent 2510function delay(): void { 2511 let start: number = new Date().getTime(); 2512 while (new Date().getTime() - start < 500) { 2513 continue; 2514 } 2515} 2516 2517let highCount: number = 0; 2518let mediumCount: number = 0; 2519let lowCount: number = 0; 2520let allCount: number = 100; 2521for (let i = 0; i < allCount; i++) { 2522 let task1: taskpool.Task = new taskpool.Task(delay); 2523 let task2: taskpool.Task = new taskpool.Task(delay); 2524 let task3: taskpool.Task = new taskpool.Task(delay); 2525 taskpool.execute(task1, taskpool.Priority.LOW).then(() => { 2526 lowCount++; 2527 }).catch((e: string) => { 2528 console.error("low task error: " + e); 2529 }) 2530 taskpool.execute(task2, taskpool.Priority.MEDIUM).then(() => { 2531 mediumCount++; 2532 }).catch((e: string) => { 2533 console.error("medium task error: " + e); 2534 }) 2535 taskpool.execute(task3, taskpool.Priority.HIGH).then(() => { 2536 highCount++; 2537 }).catch((e: string) => { 2538 console.error("high task error: " + e); 2539 }) 2540} 2541let start: number = new Date().getTime(); 2542while (new Date().getTime() - start < 1000) { 2543 continue; 2544} 2545let taskpoolInfo: taskpool.TaskPoolInfo = taskpool.getTaskPoolInfo(); 2546let tid: number = 0; 2547let taskIds: Array<number> = []; 2548let priority: number = 0; 2549let taskId: number = 0; 2550let state: number = 0; 2551let duration: number = 0; 2552let name: string = ""; 2553let threadIS = Array.from(taskpoolInfo.threadInfos) 2554for (let threadInfo of threadIS) { 2555 tid = threadInfo.tid; 2556 if (threadInfo.taskIds != undefined && threadInfo.priority != undefined) { 2557 taskIds.length = threadInfo.taskIds.length; 2558 priority = threadInfo.priority; 2559 } 2560 console.info("taskpool---tid is:" + tid + ", taskIds is:" + taskIds + ", priority is:" + priority); 2561} 2562let taskIS = Array.from(taskpoolInfo.taskInfos) 2563for (let taskInfo of taskIS) { 2564 taskId = taskInfo.taskId; 2565 state = taskInfo.state; 2566 if (taskInfo.duration != undefined) { 2567 duration = taskInfo.duration; 2568 name = taskInfo.name; 2569 } 2570 console.info("taskpool---taskId is:" + taskId + ", state is:" + state + ", duration is:" + duration + ", name is:" + name); 2571} 2572```