HarmonyOS NEXT开发实战（5.0版）Taskpool多线程操作

于 2024-09-30 15:57:48 发布
阅读量791 收藏 14
点赞数 24
分类专栏： OpenHarmony 鸿蒙开发 HarmonyOS 文章标签： harmonyos 华为 鸿蒙 鸿蒙系统 前端 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aasad66666/article/details/142658562
版权

 鸿蒙NEXT开发实战往期必看文章：

HarmonyOS NEXT应用开发案例实践总结合（持续更新......）

HarmonyOS NEXT应用开发性能优化实践总结（持续更新......）

一分钟了解”纯血版！鸿蒙HarmonyOS Next应用开发！

“非常详细的” 鸿蒙HarmonyOS Next应用开发学习路线！（从零基础入门到精通）

场景描述

场景一：周期性任务处理，业务通过taskpool周期性处理业务。

场景二：延迟业务处理，业务一段时间后，通过taskpool处理业务。

场景三：串行业务处理，业务开展过程中，需要处理一系列的事务，事务处理过程中，存在先后次序。

场景四：业务的处理存在紧急优先次序，支持设置taskpool优先级处理。

场景五：ArkTS与Native协作开展业务，在ArkTS层触发业务，通过NAPI接口，传递到Native C++层，作业务管理等处理。

方案描述

场景一：周期性任务

方案：

1)定时器判断周期性事务执行。

2)Taskpool来处理任务执行。

image.png

核心代码：

@Concurrent

function ServiceHandle(pars: number): number {

  hilog.info(0x0000, 'testTag', 'start ServiceHandle:%{public}d', pars);

  // 业务处理过程,并将结果返回

  let result = 0;

  return result;

}



let count = 0;

function TimerOutHandle(pars:number)

{

  count++;

  let task: taskpool.Task = new taskpool.Task(ServiceHandle, pars);

  hilog.info(0x0000, 'testTag', 'Timer handle count :%{public}d,pars %{public}d', count, pars);

  taskpool.execute(task, taskpool.Priority.HIGH).then((res: object) => {

    hilog.info(0x0000, 'testTag', 'ServiceHandle result :%{public}d', res);

    if (g_callback != null) {

      g_callback(count);

    }

  });

}



let timerId = -1;

export function TimerTest()

{

  count = 0;

  let value = 88;

  timerId = setInterval(TimerOutHandle, 3000, value);

}

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

运行结果：

image.png

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

image.png

场景二：延迟任务

方案：

1)通过setTimeout来延迟处理。

2) 通过executeDelayed来延迟处理。

核心代码：

1）setTimeout的处理如下：

@Concurrent

function ServiceHandle(pars: number): number {

  hilog.info(0x0000, 'testTag', 'start ServiceHandle:%{public}d', pars);

  // 业务处理过程,并将结果返回

  let result = 0;

  return result;

}



let count = 0;

function TimerOutHandle(pars:number)

{

  count++;

  let task: taskpool.Task = new taskpool.Task(ServiceHandle, pars);

  hilog.info(0x0000, 'testTag', 'Timer handle count :%{public}d,pars %{public}d', count, pars);

  taskpool.execute(task, taskpool.Priority.HIGH).then((res: object) => {

    hilog.info(0x0000, 'testTag', 'ServiceHandle result :%{public}d', res);

    if (g_callback != null) {

      g_callback(count);

    }

  });

}



export function OneTimerCallTest()

{

  count = 0;

  if (g_callback != null) {

    g_callback(count);

  }

  let value = 99;

  hilog.info(0x0000, 'testTag', 'start setTimeout');

  timerId = setTimeout(TimerOutHandle, 3000, value);

}

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

2）executeDelayed来延迟

@Concurrent

function TaskDelayServiceHandle(pars: number): number {

  let t: number = Date.now();

  hilog.info(0x0000, 'testTag', 'enter TaskDelayServiceHandle, timer is :%{public}d', t);

  // 业务处理过程,并将结果返回

  let result = 0;

  return result;

}



export function TaskPoolDelayTest()

{

  count = 0;

  if (g_callback != null) {

    g_callback(count);

  }

  let value = 100;

  let t: number = Date.now();

  hilog.info(0x0000, 'testTag', 'taskpool start time is :%{public}d', t);

  let task: taskpool.Task = new taskpool.Task(TaskDelayServiceHandle, value);

  taskpool.executeDelayed(3000, task).then(() => {

    count++;

    let t: number = Date.now();

    hilog.info(0x0000, 'testTag', 'taskpool execute success, time is :%{public}d', t);

    if (g_callback != null) {

      g_callback(count);

    }

  }).catch((e: BusinessError) => {

    console.error(`taskpool execute: Code: ${e.code}, message: ${e.message}`);

  })

}

调用executeDelayed函数3秒后，会进入TaskDelayServiceHandle函数执行，返回返回后，会进入executeDelayed后面的then的函数体中执行。

运行结果：

1）使用setTimeout运行结果

image.png

2）使用executeDelayed运行结果

image.png

场景三：串行任务

方案：

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

image.png

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

image.png

核心代码：

1）通过业务逻辑的结果来处理

@Concurrent

function ServiceHandle1(pars: number): number {

  hilog.info(0x0000, 'testTag', 'start ServiceHandle1:%{public}d', pars);

  // 业务处理过程,并将结果返回

  let result = 0;

  return result;

}



@Concurrent

function ServiceHandle2(pars: number): number {

  hilog.info(0x0000, 'testTag', 'start ServiceHandle2:%{public}d', pars);

  // 业务处理过程,并将结果返回

  let result = 1;

  return result;

}



export function SyncHandle()

{

  let task1: taskpool.Task = new taskpool.Task(ServiceHandle1, 1);

  hilog.info(0x0000, 'testTag', 'sync handle');

  taskpool.execute(task1, taskpool.Priority.HIGH).then((res1: object) => {

    hilog.info(0x0000, 'testTag', 'ServiceHandle result :%{public}d', res1);

    if (g_callback != null) {

      g_callback('task1 finish.');

    }

    if ((res1 as Number) == 0) {

      let task2: taskpool.Task = new taskpool.Task(ServiceHandle2, 2);

      taskpool.execute(task2, taskpool.Priority.HIGH).then((res2: object) => {

        hilog.info(0x0000, 'testTag', 'ServiceHandle2 result :%{public}d', res2);

        if (g_callback != null) {

          g_callback('task2 finish.');

        }

      });

    }

  });

}

task1执行完毕后，根据if判断启动task2任务执行。

2）通过addDependency或SequenceRunner处理。

@Concurrent

function DependencyHandle(args: number): number {

  let t: number = Date.now();

  while ((Date.now() - t) < 1000) {

    continue;

  }

  return args;

}



export function AddDependencyTest()

{

  let task1:taskpool.Task = new taskpool.Task(DependencyHandle, 100);

  let task2:taskpool.Task = new taskpool.Task(DependencyHandle, 200);

  let task3:taskpool.Task = new taskpool.Task(DependencyHandle, 300);



  hilog.info(0x0000, 'testTag', 'dependency: add dependency start');

  task1.addDependency(task2);

  task2.addDependency(task3);

  hilog.info(0x0000, 'testTag', 'dependency: add dependency end');



  hilog.info(0x0000, 'testTag', 'dependency: start execute second');

  taskpool.execute(task1).then(() => {

    hilog.info(0x0000, 'testTag', 'dependency: first task1 success');

    if (g_callback != null) {

      g_callback('task1 finish.');

    }

  })

  taskpool.execute(task2).then(() => {

    hilog.info(0x0000, 'testTag', 'dependency: second task2 success');

    if (g_callback != null) {

      g_callback('task2 finish.');

    }

  })

  taskpool.execute(task3).then(() => {

    hilog.info(0x0000, 'testTag', 'dependency: third task3 success');

    if (g_callback != null) {

      g_callback('task3 finish.');

    }

  })

}

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

@Concurrent

function additionDelay(delay:number): void {

  let start: number = new Date().getTime();

  while (new Date().getTime() - start < delay) {

    continue;

  }

}

@Concurrent

function waitForRunner(finalString: string): string {

  return finalString;

}

export async function SeqRunnerTest()

{

  let finalString:string = "";

  let task1:taskpool.Task = new taskpool.Task(additionDelay, 3000);

  let task2:taskpool.Task = new taskpool.Task(additionDelay, 2000);

  let task3:taskpool.Task = new taskpool.Task(additionDelay, 1000);

  let task4:taskpool.Task = new taskpool.Task(waitForRunner, finalString);



  let runner:taskpool.SequenceRunner = new taskpool.SequenceRunner();

  runner.execute(task1).then(() => {

    finalString += 'task1 finish.';

    hilog.info(0x0000, 'testTag', 'seqrunner: task1 done.');

    if (g_callback != null) {

      g_callback('task1 finish.');

    }

  });

  runner.execute(task2).then(() => {

    finalString += 'task2 finish.';

    hilog.info(0x0000, 'testTag', 'seqrunner: task2 done.');

    if (g_callback != null) {

      g_callback('task2 finish.');

    }

  });

  runner.execute(task3).then(() => {

    finalString += 'task3 finish.';

    hilog.info(0x0000, 'testTag', 'seqrunner: task3 done.');

    if (g_callback != null) {

      g_callback('task3 finish.');

    }

  });

  await runner.execute(task4);

  hilog.info(0x0000, 'testTag', 'seqrunner: task4 done, finalString is %{public}s', finalString);

}

task1执行完毕后，执行task2，最后是task3执行完毕。

运行结果：

1）通过业务逻辑的结果来处理

image.png

2）通过addDependency或SequenceRunner处理

image.png

场景四：优先级任务

方案：

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

核心代码：

@Concurrent

function ServiceHandle(pri: string): string {

  hilog.info(0x0000, 'testTag', 'enter ServiceHandle:%{public}s', pri);

  hilog.info(0x0000, 'testTag', 'end ServiceHandle:%{public}s', pri);



  return pri;

}



export function CallPriorityHanel()

{

  let task1: taskpool.Task = new taskpool.Task(ServiceHandle, "LOW");

  let task2: taskpool.Task = new taskpool.Task(ServiceHandle, "MEDIUM");

  let task3: taskpool.Task = new taskpool.Task(ServiceHandle, "HIGH");



  taskpool.execute(task1, taskpool.Priority.LOW).then((res: object) => {

    hilog.info(0x0000, 'testTag', 'task return result :%{public}s', res);

  });

  taskpool.execute(task2, taskpool.Priority.MEDIUM).then((res: object) => {

    hilog.info(0x0000, 'testTag', 'task return result :%{public}s', res);

  });

  taskpool.execute(task3, taskpool.Priority.HIGH).then((res: object) => {

    hilog.info(0x0000, 'testTag', 'task return result :%{public}s', res);

  });

}

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

运行结果：

image.png

场景五：taskpool的Napi调用

方案：C++层编译的库，在ArkTS层通过import库的方式引用后，在taskpool的回调函数中调用接口。核心代码：

@Concurrent

function ServiceHandle(pars: number): number {

  hilog.info(0x0000, 'testTag', 'start ServiceHandle:%{public}d', pars);

  // 业务处理过程,并将结果返回

  testNapi.jsServiceHandle(88, 99);

  return 0;

}



export function CallHandle()

{

  let task: taskpool.Task = new taskpool.Task(ServiceHandle, 1);



  taskpool.execute(task,).then((res: object) => {

    hilog.info(0x0000, 'testTag', 'printArgs result :%{public}d', res);

  });

}

typedef struct TestData {

  int data;

  int type;

} TestData;



static napi_value JsServiceHandle(napi_env env, napi_callback_info info)

{

  size_t argc = 2;

  napi_value args[2] = {nullptr};



  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);



  TestData testData;

  napi_get_value_int32(env, args[0], &testData.data);

  napi_get_value_int32(env, args[1], &testData.type);



  OH_LOG_INFO(LOG_APP, "Native C++ Service handle：%{public}d,type：%{public}d", testData.data, testData.type);



  return nullptr;

}



EXTERN_C_START

static napi_value Init(napi_env env, napi_value exports)

{

  napi_property_descriptor desc[] = {

  {"jsServiceHandle", nullptr, JsServiceHandle, nullptr, nullptr, nullptr, napi_default, nullptr}

};

napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);



return exports;

}

EXTERN_C_END

运行结果：

image.png

最后

小编在之前的鸿蒙系统扫盲中，有很多朋友给我留言，不同的角度的问了一些问题，我明显感觉到一点，那就是许多人参与鸿蒙开发，但是又不知道从哪里下手，因为资料太多，太杂，无从选择。有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）文档用来跟着学习是非常有必要的。

如果你是一名有经验的资深Android移动开发、Java开发、前端开发、对鸿蒙感兴趣以及转行人员

→   鸿蒙HarmonyOS Next 全栈开发学习笔记 希望这一份鸿蒙学习文档能够给大家带来帮助~

这份鸿蒙（HarmonyOS NEXT）包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、（南向驱动、嵌入式等）鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。

代码老出BUG
关注
专栏目录
从零开始的HarmonyOS Next开发指南：打造HarmonyOS NEXT元服务
一键难忘的博客
05-26 5713
DevEco Studio 4.0是一个集成开发环境（IDE），专门为开发者提供一站式的HarmonyOS应用和服务开发支持。以下是DevEco Studio 4.0的一些主要特点：高效智能代码编辑：支持多种语言，如ArkTS、JavaScript、C/C++等，提供代码高亮、智能补齐、错误检查、自动跳转、格式化、查找等功能，以提升代码编写的效率。低代码可视化开发：拥有丰富的UI界面编辑能力，支持自由拖拽组件和可视化数据绑定，能够快速预览效果，所见即所得。
HarmonyOS 应用开发之Worker
1
04-01 1435
Worker主要作用是为应用程序提供一个多线程的运行环境，可满足应用程序在执行过程中与主线程分离，在后台线程中运行一个脚本操作耗时操作，极大避免类似于计算密集型或高延迟的任务阻塞主线程的运行。
【鸿蒙实战开发】基于Taskpool的多线程操作
HarmonyOSMN的博客
06-28 886
周期性任务处理，业务通过taskpool周期性处理业务。：延迟业务处理，业务一段时间后，通过taskpool处理业务。：串行业务处理，业务开展过程中，需要处理一系列的事务，事务处理过程中，存在先后次序。：业务的处理存在紧急优先次序，支持设置taskpool优先级处理。：ArkTS与Native协作开展业务，在ArkTS层触发业务，通过NAPI接口，传递到Native C++层，作业务管理等处理。方案：1)定时器判断周期性事务执行。2)Taskpool来处理任务执行。
【鸿蒙开发】第十五章 ArkTS基础类库-并发
Yvan
03-03 1902
为了提升应用的响应速度与帧率，以及防止耗时任务对主线程的干扰，系统提供了异步并发和多线程并发两种处理策略，ArkTS支持异步并发和多线程并发。并发能力在多种场景中都有应用，其中包括单次I/O任务CPU密集型任务I/O密集型任务和同步任务等。：是指异步代码在执行到一定程度后会被暂停，以便在未来某个时间点继续执行，这种情况下，同一时间只有一段代码在执行。Promise和提供异步并发能力，适用于单次I/O任务的开发场景。详细请参见异步并发概述。：允许在同一时间段内同时执行多段代码。
鸿蒙「TaskPool|Worker」多线程并发使用详解，这一篇足够！
最新发布
文化园
08-15 1982
CPU密集型任务，说白了是计算型耗时任务； I/O密集型任务，说白了是读写型耗时任务； 官方文档重点介绍了这两种基于多线程并发机制处理任务类型，我们是要深度思考下的？！「很有意义」，是否已经包含且指明了我们使用「TaskPool/Worker」来解决项目问题的方案呢？ 对Worker以及TaskPool的使用详解，个人准备以一种特别的角度来详述。从我个人初始接触及学习研究的视角，针对 `如何选用`、`如何创建`、`如何使用`、`注意事项`和`条件限制` 多个方面，全面剖析。
OpenHarmony实战开发-如何启动worker线程和taskpool线程。
2401_82546228的博客
04-14 805
本示例通过@ohos.taskpool 和@ohos.worker 接口，展示了如何启动worker线程和taskpool线程。
黑马HarmonyOS-NEXT星河版实战-课程网盘链接提取码下载 .txt
06-03
"黑马HarmonyOS-NEXT星河版实战"课程旨在帮助学员深入了解HarmonyOS-NEXT星河版操作系统的开发和实际应用。学员将学习操作系统原理、应用开发技巧和界面设计，通过实战项目提升技能。课程注重实践与理论相结合，为...
黑马程序员HarmonyOS4+NEXT星河版入门到企业级实战教程，一套精通鸿蒙应用开发41-50
06-29
黑马程序员HarmonyOS4+NEXT星河版入门到企业级实战教程，一套精通鸿蒙应用开发41-50
全网首发黑马程序员鸿蒙 HarmonyOS NEXT星河版零基础入门到实战，零基础也能快速入门鸿蒙开发教程1
05-16
全网首发黑马程序员鸿蒙 HarmonyOS NEXT星河版零基础入门到实战，零基础也能快速入门鸿蒙开发教程1
详细教程 - 进阶版 鸿蒙harmonyOS应用 第十七节——鸿蒙OS多线程编程指南
爱蹦跶的全栈大A阿
12-22 2587
线程是操作系统调度的最小单元,鸿蒙OS使用轻量级线程实现了良好的并发性能。相比进程间的切换,线程间切换成本更低,可以有效利用多核CPU。但直接使用线程也会增加编程复杂度。本文将详细介绍鸿蒙OS的多线程编程模型、线程间通信与同步机制、并发安全、最佳实践等内容。本文主要介绍了鸿蒙OS的多线程创建与同步互斥机制,解释了线程不安全的根本原因,并给出了设计实现线程安全的各种方式,最后提出了并发优化的最佳实践。多线程并发大大提高了程序执行效率,但也增加了编程难度。
HarmonyOS开发学习：定位相关知识（Locationkit）
DMZDAMS的博客
07-08 945
HarmonyOS 应用开发工具DevEco Studio也没有提供读取存储器的功能，所以做一个简单版本的应用级别浏览器还是有必要的。
鸿蒙（HarmonyOS）性能优化实战-多线程共享内存
maniuT的博客
04-23 1231
在应用开发中，为了避免主线程阻塞，提高应用性能，需要将一些耗时操作放在子线程中执行。此时，子线程就需要访问主线程中的数据。ArkTS采用了基于消息通信的Actor并发模型，具有内存隔离的特性，所以跨线程传输数据时需要将数据序列化，但是AkrTS支持通过可共享对象SharedArrayBuffer实现直接的共享内存。在开发应用时，如果遇到数据量较大，并且需要多个线程同时操作的情况，推荐使用SharedArrayBuffer共享内存，可以减少数据在线程间传递时需要复制和序列化的额外开销。
鸿蒙OpenHarmony多线程能力场景化示例实践
1
02-29 1517
在OpenHarmony应用中，每个 进程 都会有一个主线程，主线程主要承担执行UI绘制操作、管理ArkTS引擎实例的创建和销毁、分发和处理事件、管理Ability生命周期等职责，具体可参见 线程模型概述。因此，开发应用时应当尽量避免将耗时的操作放在主线程中执行。ArkTS提供了Worker和TaskPool两种多线程并发能力，多线程并发允许在同一时间段内同时执行多段代码，这两个并发的基本能力可参见 TaskPool和Worker的对比。在介绍Worker和TaskPool。
自学鸿蒙应用开发（39）- 使用多线程功能实现定时器
面向对象思考
09-16 835
很多应用需要按照一定周期执行某些特定动作，本文通过一个时钟小例子介绍使用使用鸿蒙系统的多线程功能实现这一功能。以下是动作视频： demo 准备布局 下面的代码为了方便实现，使用TimePicker表示现在时间： <?xml version="1.0" encoding="utf-8"?><DirectionalLayout xmlns:ohos="http://schemas.huawei.com/res/ohos" ohos:height="match_p
OpenHarmony实战开发-合理使用多线程共享内存。
m0_70749039的博客
04-22 929
在应用开发中，为了避免主线程阻塞，提高应用性能，需要将一些耗时操作放在子线程中执行。此时，子线程就需要访问主线程中的数据。ArkTS采用了基于消息通信的Actor并发模型，具有内存隔离的特性，所以跨线程传输数据时需要将数据序列化，但是AkrTS支持通过可共享对象SharedArrayBuffer实现直接的共享内存。
嵌入式linux/鸿蒙开发板(IMX6ULL）开发（十七）多线程编程
da.的博客
03-13 910
文章目录1.多线程编程1.1 线程的使用1.1.1 为什么要使用多线程1.1.2 线程概念1.1.3 线程的标识pthread_t1.1.4 线程的创建1.1.5向线程传入参数1.1.6线程的退出与回收1.2 线程的控制1.2.1 多线程编临界资源访问1.2.2 互斥锁API简述1.2.3 多线程编执行顺序控制1.2.4 信号量API简述1.2.5 条件变量1.3 总结1.3.1 线程使用流程图1.3.2 互斥量使用流程图1.3.2 信号量使用流程图 1.多线程编程 本章将分为两大部分进行讲解，第一部分将引
CH11-HarmonyOS网络与多线程
weixin_46227276的博客
01-26 3315
文章目录前言目标Http接口调用HttpRequestOptions发起请求HttpResponse数据上传和下载DownloadConfig数据上传和下载示例代码WebSocket概念操作步骤连接打开并发送接受消息并关闭多线程概念线程的作用HarmonyOS中线程的实现同步派发syncDispatch异步派发asyncDispatch本章总结 前言 随着移动互联网的发展，人们越来越依赖手机上的浏览器，或者是具备网络访问功能的App来获取资源 如淘宝，美团等通过移动端应用来获取服务器上的商品信息和生活信息
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值