【鸿蒙实战开发】基于Taskpool的多线程操作

场景形貌

场景一：周期性任务处理，业务通过taskpool周期性处理业务。
场景二：延迟业务处理，业务一段时间后，通过taskpool处理业务。
场景三：串行业务处理，业务开展过程中，必要处理一系列的事务，事务处理过程中，存在先后次序。
场景四：业务的处理存在紧急优先次序，支持设置taskpool优先级处理。
场景五：ArkTS与Native协作开展业务，在ArkTS层触发业务，通过NAPI接口，通报到Native C++层，作业务管理等处理。
方案形貌

场景一：周期性任务

方案：
1)定时器判定周期性事务实行。
2)Taskpool来处理任务实行。

焦点代码：

1. @Concurrent
3. function ServiceHandle(pars: number): number {
5.   hilog.info(0x0000, 'testTag', 'start ServiceHandle:%{public}d', pars);
7.   // 业务处理过程,并将结果返回
9.   let result = 0;
11.   return result;
13. }
15. let count = 0;
17. function TimerOutHandle(pars:number)
19. {
21.   count++;
23.   let task: taskpool.Task = new taskpool.Task(ServiceHandle, pars);
25.   hilog.info(0x0000, 'testTag', 'Timer handle count :%{public}d,pars %{public}d', count, pars);
27.   taskpool.execute(task, taskpool.Priority.HIGH).then((res: object) => {
29.     hilog.info(0x0000, 'testTag', 'ServiceHandle result :%{public}d', res);
31.     if (g_callback != null) {
33.       g_callback(count);
35.     }
37.   });
39. }
41. let timerId = -1;
43. export function TimerTest()
45. {
47.   count = 0;
49.   let value = 88;
51.   timerId = setInterval(TimerOutHandle, 3000, value);
53. }

复制代码

定时器每3秒超时一次，进入TimerOutHandle函数处理，TimerOutHandle函数体中，通过taskpool创建异步并发任务实行业务。
运行结果：

界面上，每超时一次，会出现运行次数：

场景二：延迟任务

方案：
1)通过setTimeout来延迟处理。

• 通过executeDelayed来延迟处理。
  

焦点代码：
1）setTimeout的处理如下：

1. @Concurrent
3. function ServiceHandle(pars: number): number {
5.   hilog.info(0x0000, 'testTag', 'start ServiceHandle:%{public}d', pars);
7.   // 业务处理过程,并将结果返回
9.   let result = 0;
11.   return result;
13. }
15. let count = 0;
17. function TimerOutHandle(pars:number)
19. {
21.   count++;
23.   let task: taskpool.Task = new taskpool.Task(ServiceHandle, pars);
25.   hilog.info(0x0000, 'testTag', 'Timer handle count :%{public}d,pars %{public}d', count, pars);
27.   taskpool.execute(task, taskpool.Priority.HIGH).then((res: object) => {
29.     hilog.info(0x0000, 'testTag', 'ServiceHandle result :%{public}d', res);
31.     if (g_callback != null) {
33.       g_callback(count);
35.     }
37.   });
39. }
41. export function OneTimerCallTest()
43. {
45.   count = 0;
47.   if (g_callback != null) {
49.     g_callback(count);
51.   }
53.   let value = 99;
55.   hilog.info(0x0000, 'testTag', 'start setTimeout');
57.   timerId = setTimeout(TimerOutHandle, 3000, value);
59. }

复制代码

定时器3秒超时（仅仅实行一次）后，就会进入TimerOutHandle函数处理，TimerOutHandle函数体中，通过taskpool创建异步并发任务实行业务。
2）executeDelayed来延迟

1. @Concurrent
3. function TaskDelayServiceHandle(pars: number): number {
5.   let t: number = Date.now();
7.   hilog.info(0x0000, 'testTag', 'enter TaskDelayServiceHandle, timer is :%{public}d', t);
9.   // 业务处理过程,并将结果返回
11.   let result = 0;
13.   return result;
15. }
17. export function TaskPoolDelayTest()
19. {
21.   count = 0;
23.   if (g_callback != null) {
25.     g_callback(count);
27.   }
29.   let value = 100;
31.   let t: number = Date.now();
33.   hilog.info(0x0000, 'testTag', 'taskpool start time is :%{public}d', t);
35.   let task: taskpool.Task = new taskpool.Task(TaskDelayServiceHandle, value);
37.   taskpool.executeDelayed(3000, task).then(() => {
39.     count++;
41.     let t: number = Date.now();
43.     hilog.info(0x0000, 'testTag', 'taskpool execute success, time is :%{public}d', t);
45.     if (g_callback != null) {
47.       g_callback(count);
49.     }
51.   }).catch((e: BusinessError) => {
53.     console.error(`taskpool execute: Code: ${e.code}, message: ${e.message}`);
55.   })
57. }

复制代码

调用executeDelayed函数3秒后，会进入TaskDelayServiceHandle函数实行，返回返回后，会进入executeDelayed后面的then的函数体中实行。
运行结果：
1）利用setTimeout运行结果

2）利用executeDelayed运行结果

场景三：串行任务

方案：
1）最简朴的方案就是后面任务实行时，根据前面任务的实行结果来处理。

2）后面任务的实行，依靠另一个任务的一些处理结果后，继续实行。

焦点代码：
1）通过业务逻辑的结果来处理

1. @Concurrent
3. function ServiceHandle1(pars: number): number {
5.   hilog.info(0x0000, 'testTag', 'start ServiceHandle1:%{public}d', pars);
7.   // 业务处理过程,并将结果返回
9.   let result = 0;
11.   return result;
13. }
15. @Concurrent
17. function ServiceHandle2(pars: number): number {
19.   hilog.info(0x0000, 'testTag', 'start ServiceHandle2:%{public}d', pars);
21.   // 业务处理过程,并将结果返回
23.   let result = 1;
25.   return result;
27. }
29. export function SyncHandle()
31. {
33.   let task1: taskpool.Task = new taskpool.Task(ServiceHandle1, 1);
35.   hilog.info(0x0000, 'testTag', 'sync handle');
37.   taskpool.execute(task1, taskpool.Priority.HIGH).then((res1: object) => {
39.     hilog.info(0x0000, 'testTag', 'ServiceHandle result :%{public}d', res1);
41.     if (g_callback != null) {
43.       g_callback('task1 finish.');
45.     }
47.     if ((res1 as Number) == 0) {
49.       let task2: taskpool.Task = new taskpool.Task(ServiceHandle2, 2);
51.       taskpool.execute(task2, taskpool.Priority.HIGH).then((res2: object) => {
53.         hilog.info(0x0000, 'testTag', 'ServiceHandle2 result :%{public}d', res2);
55.         if (g_callback != null) {
57.           g_callback('task2 finish.');
59.         }
61.       });
63.     }
65.   });
67. }

复制代码

task1实行完毕后，根据if判定启动task2任务实行。
2）通过addDependency或SequenceRunner处理。

1. @Concurrent
3. function DependencyHandle(args: number): number {
5.   let t: number = Date.now();
7.   while ((Date.now() - t) < 1000) {
9.     continue;
11.   }
13.   return args;
15. }
17. export function AddDependencyTest()
19. {
21.   let task1:taskpool.Task = new taskpool.Task(DependencyHandle, 100);
23.   let task2:taskpool.Task = new taskpool.Task(DependencyHandle, 200);
25.   let task3:taskpool.Task = new taskpool.Task(DependencyHandle, 300);
27.   hilog.info(0x0000, 'testTag', 'dependency: add dependency start');
29.   task1.addDependency(task2);
31.   task2.addDependency(task3);
33.   hilog.info(0x0000, 'testTag', 'dependency: add dependency end');
35.   hilog.info(0x0000, 'testTag', 'dependency: start execute second');
37.   taskpool.execute(task1).then(() => {
39.     hilog.info(0x0000, 'testTag', 'dependency: first task1 success');
41.     if (g_callback != null) {
43.       g_callback('task1 finish.');
45.     }
47.   })
49.   taskpool.execute(task2).then(() => {
51.     hilog.info(0x0000, 'testTag', 'dependency: second task2 success');
53.     if (g_callback != null) {
55.       g_callback('task2 finish.');
57.     }
59.   })
61.   taskpool.execute(task3).then(() => {
63.     hilog.info(0x0000, 'testTag', 'dependency: third task3 success');
65.     if (g_callback != null) {
67.       g_callback('task3 finish.');
69.     }
71.   })
73. }

复制代码

task1依靠task2，task2依靠task3，上面任务实行的顺序是：task3实行完毕后再实行task2，最后实行task。

1. @Concurrent
3. function additionDelay(delay:number): void {
5.   let start: number = new Date().getTime();
7.   while (new Date().getTime() - start < delay) {
9.     continue;
11.   }
13. }
15. @Concurrent
17. function waitForRunner(finalString: string): string {
19.   return finalString;
21. }
23. export async function SeqRunnerTest()
25. {
27.   let finalString:string = "";
29.   let task1:taskpool.Task = new taskpool.Task(additionDelay, 3000);
31.   let task2:taskpool.Task = new taskpool.Task(additionDelay, 2000);
33.   let task3:taskpool.Task = new taskpool.Task(additionDelay, 1000);
35.   let task4:taskpool.Task = new taskpool.Task(waitForRunner, finalString);
37.   let runner:taskpool.SequenceRunner = new taskpool.SequenceRunner();
39.   runner.execute(task1).then(() => {
41.     finalString += 'task1 finish.';
43.     hilog.info(0x0000, 'testTag', 'seqrunner: task1 done.');
45.     if (g_callback != null) {
47.       g_callback('task1 finish.');
49.     }
51.   });
53.   runner.execute(task2).then(() => {
55.     finalString += 'task2 finish.';
57.     hilog.info(0x0000, 'testTag', 'seqrunner: task2 done.');
59.     if (g_callback != null) {
61.       g_callback('task2 finish.');
63.     }
65.   });
67.   runner.execute(task3).then(() => {
69.     finalString += 'task3 finish.';
71.     hilog.info(0x0000, 'testTag', 'seqrunner: task3 done.');
73.     if (g_callback != null) {
75.       g_callback('task3 finish.');
77.     }
79.   });
81.   await runner.execute(task4);
83.   hilog.info(0x0000, 'testTag', 'seqrunner: task4 done, finalString is %{public}s', finalString);
85. }

复制代码

task1实行完毕后，实行task2，最后是task3实行完毕。
运行结果：
1）通过业务逻辑的结果来处理

2）通过addDependency或SequenceRunner处理

场景四：优先级任务

方案：
在taskpool.execute的参数二种设置线程的优先级，优先级分三个级别：LOW、MEDIUM（默认）、HIGH。通过设置优先级来运行taskpool任务。
焦点代码：

1. @Concurrent
3. function ServiceHandle(pri: string): string {
5.   hilog.info(0x0000, 'testTag', 'enter ServiceHandle:%{public}s', pri);
7.   hilog.info(0x0000, 'testTag', 'end ServiceHandle:%{public}s', pri);
9.   return pri;
11. }
13. export function CallPriorityHanel()
15. {
17.   let task1: taskpool.Task = new taskpool.Task(ServiceHandle, "LOW");
19.   let task2: taskpool.Task = new taskpool.Task(ServiceHandle, "MEDIUM");
21.   let task3: taskpool.Task = new taskpool.Task(ServiceHandle, "HIGH");
23.   taskpool.execute(task1, taskpool.Priority.LOW).then((res: object) => {
25.     hilog.info(0x0000, 'testTag', 'task return result :%{public}s', res);
27.   });
29.   taskpool.execute(task2, taskpool.Priority.MEDIUM).then((res: object) => {
31.     hilog.info(0x0000, 'testTag', 'task return result :%{public}s', res);
33.   });
35.   taskpool.execute(task3, taskpool.Priority.HIGH).then((res: object) => {
37.     hilog.info(0x0000, 'testTag', 'task return result :%{public}s', res);
39.   });
41. }

复制代码

当前的设备都是多核的，并不是说将优先级设置程HIGH,该任务就会最先调理。
运行结果：

场景五：taskpool的Napi调用
方案：C++层编译的库，在ArkTS层通过import库的方式引用后，在taskpool的回调函数中调用接口。焦点代码：

1. @Concurrent
3. function ServiceHandle(pars: number): number {
5.   hilog.info(0x0000, 'testTag', 'start ServiceHandle:%{public}d', pars);
7.   // 业务处理过程,并将结果返回
9.   testNapi.jsServiceHandle(88, 99);
11.   return 0;
13. }
15. export function CallHandle()
17. {
19.   let task: taskpool.Task = new taskpool.Task(ServiceHandle, 1);
21.   taskpool.execute(task,).then((res: object) => {
23.     hilog.info(0x0000, 'testTag', 'printArgs result :%{public}d', res);
25.   });
27. }
29. typedef struct TestData {
31.   int data;
33.   int type;
35. } TestData;
37. static napi_value JsServiceHandle(napi_env env, napi_callback_info info)
39. {
41.   size_t argc = 2;
43.   napi_value args[2] = {nullptr};
45.   napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
47.   TestData testData;
49.   napi_get_value_int32(env, args[0], &testData.data);
51.   napi_get_value_int32(env, args[1], &testData.type);
53.   OH_LOG_INFO(LOG_APP, "Native C++ Service handle：%{public}d,type：%{public}d", testData.data, testData.type);
55.   return nullptr;
57. }
59. EXTERN_C_START
61. static napi_value Init(napi_env env, napi_value exports)
63. {
65.   napi_property_descriptor desc[] = {
67.   {"jsServiceHandle", nullptr, JsServiceHandle, nullptr, nullptr, nullptr, napi_default, nullptr}
69. };
71. napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
73. return exports;
75. }
77. EXTERN_C_END

复制代码

运行结果：

鸿蒙全栈开发全新学习指南

为了积极培养鸿蒙生态人才，让大家都能学习到鸿蒙开发最新的技能，针对一些在职人员、0基础小白、应届生/计算机专业、鸿蒙爱好者等人群，整理了一套纯血版鸿蒙（HarmonyOS Next）全栈开发技能的学习门路【包罗了大厂APP实战项目开发】。
本门路共分为四个阶段：

第一阶段：鸿蒙初中级开发必备技能

第二阶段：鸿蒙南北双向高工技能基础：gitee.com/MNxiaona/733GH

第三阶段：应用开发中高级就业技能

第四阶段：全网首发-工业级南向设备开发就业技能：gitee.com/MNxiaona/733GH

《鸿蒙 (Harmony OS)开发学习手册》（共计892页）

如何快速入门？

1.根本概念
2.构建第一个ArkTS应用
3.……

开发基础知识:gitee.com/MNxiaona/733GH

1.应用基础知识
2.配置文件
3.应用数据管理
4.应用安全管理
5.应用隐私保护
6.三方应用调用管控机制
7.资源分类与访问
8.学习ArkTS语言
9.……

基于ArkTS 开发

1.Ability开发
2.UI开发
3.公共事件与通知
4.窗口管理
5.媒体
6.安全
7.网络与链接
8.电话服务
9.数据管理
10.背景任务(Background Task)管理
11.设备管理
12.设备利用信息统计
13.DFX
14.国际化开发
15.折叠屏系列
16.……

鸿蒙开发口试真题（含参考答案）:gitee.com/MNxiaona/733GH

鸿蒙入门讲授视频：

美团APP实战开发讲授：gitee.com/MNxiaona/733GH

写在最后

• 假如你觉得这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙：
  
• 点赞，转发，有你们的 『点赞和评论』，才是我创造的动力。
  
• 关注小编，同时可以等待后续文章ing