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

于 2024-09-05 14:32:49 发布
阅读量692 收藏 23
点赞数 17
分类专栏： HarmonyOS 移动开发 鸿蒙开发 文章标签： harmonyos OpenHarmony 鸿蒙开发 多线程 移动开发 组件化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CTrup/article/details/141930314
版权
移动开发 同时被 3 个专栏收录
238 篇文章 1 订阅
订阅专栏
鸿蒙开发
238 篇文章 0 订阅
订阅专栏
HarmonyOS
200 篇文章 0 订阅
订阅专栏

往期知识点整理

场景描述

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

方案描述

场景一：周期性任务

方案：

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

2)Taskpool来处理任务执行。

核心代码：

@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创建异步并发任务执行业务。

运行结果：

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

场景二：延迟任务

方案：

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运行结果

2）使用executeDelayed运行结果

场景三：串行任务

方案：

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

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

核心代码：

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）通过业务逻辑的结果来处理

2）通过addDependency或SequenceRunner处理

场景四：优先级任务

方案：

在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,该任务就会最先调度。

运行结果：

场景五：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

运行结果：

总是有很多小伙伴反馈说：OpenHarmony开发不知道学习哪些技术？不知道需要重点掌握哪些OpenHarmony开发知识点？ 为了解决大家这些学习烦恼。在这准备了一份很实用的鸿蒙全栈开发学习路线与学习文档给大家用来跟着学习。

针对一些列因素，整理了一套纯血版鸿蒙（HarmonyOS Next）全栈开发技术的学习路线，包含了鸿蒙开发必掌握的核心知识要点，内容有（OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、OpenHarmony驱动开发、系统定制移植……等）技术知识点。

《鸿蒙 (Harmony OS)开发学习手册》（共计892页）:https://gitcode.com/HarmonyOS_MN/733GH/overview

如何快速入门？

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

开发基础知识:

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.……

在这里插入图片描述

鸿蒙开发面试真题（含参考答案）:https://gitcode.com/HarmonyOS_MN/733GH/overview

在这里插入图片描述

OpenHarmony 开发环境搭建

图片

《OpenHarmony源码解析》:https://gitcode.com/HarmonyOS_MN/733GH/overview

  • 搭建开发环境
  • Windows 开发环境的搭建
  • Ubuntu 开发环境搭建
  • Linux 与 Windows 之间的文件共享
  • ……
  • 系统架构分析
  • 构建子系统
  • 启动流程
  • 子系统
  • 分布式任务调度子系统
  • 分布式通信子系统
  • 驱动子系统
  • ……

图片

OpenHarmony 设备开发学习手册:https://gitcode.com/HarmonyOS_MN/733GH/overview

图片

CTrup
关注
专栏目录
2024鸿蒙OS实战开发项目大全：从入门到精通（含101个实战案例）超详细的鸿蒙实战案例
sybh的博客
05-17 4028
从基础的UI组件到复杂的分布式场景，从ArkTS的细致教学到JS的灵活运用，这一百个项目涵盖了你需要知道的HarmonyOS实战技术和策略。我们会从溪村小镇的细节世界开始，深入多端部署的可能性，感受如购物应用和音乐专辑这样的实用系统是如何在HarmonyOS中获得生命的。忘却繁杂，把握简单，最后我们将以开发您的第一个快应用（初级版和高级版）为终结，为您的鸿蒙OS开发之旅画上完美的句号。这一百个项目不仅仅是教程或示例，它们是设计思维、创新灵感和开发技巧的集大成，是您实战开发HarmonyOS路上的重要伴侣。
HarmonyOS 应用开发之TaskPool和Worker的对比 (TaskPool和Worker)
1
04-01 1312
TaskPool（任务池）和Worker的作用是为应用程序提供一个多线程的运行环境，用于处理耗时的计算任务或其他密集型任务。可以有效地避免这些任务阻塞主线程，从而最大化系统的利用率，降低整体资源消耗，并提高系统的整体性能。本文将从 实现特点 和 适用场景 两个方面来进行TaskPool与Worker的比较。
鸿蒙「TaskPool|Worker」多线程并发使用详解，这一篇足够！
最新发布
文化园
08-15 1617
CPU密集型任务，说白了是计算型耗时任务； I/O密集型任务，说白了是读写型耗时任务； 官方文档重点介绍了这两种基于多线程并发机制处理任务类型，我们是要深度思考下的？！「很有意义」，是否已经包含且指明了我们使用「TaskPool/Worker」来解决项目问题的方案呢？ 对Worker以及TaskPool的使用详解，个人准备以一种特别的角度来详述。从我个人初始接触及学习研究的视角，针对 `如何选用`、`如何创建`、`如何使用`、`注意事项`和`条件限制` 多个方面，全面剖析。
OpenHarmony实战开发-如何启动worker线程和taskpool线程。
2401_82546228的博客
04-14 770
本示例通过@ohos.taskpool 和@ohos.worker 接口，展示了如何启动worker线程和taskpool线程。
【鸿蒙开发】第十五章 ArkTS基础类库-并发
Yvan
03-03 1792
为了提升应用的响应速度与帧率，以及防止耗时任务对主线程的干扰，系统提供了异步并发和多线程并发两种处理策略，ArkTS支持异步并发和多线程并发。并发能力在多种场景中都有应用，其中包括单次I/O任务CPU密集型任务I/O密集型任务和同步任务等。：是指异步代码在执行到一定程度后会被暂停，以便在未来某个时间点继续执行，这种情况下，同一时间只有一段代码在执行。Promise和提供异步并发能力，适用于单次I/O任务的开发场景。详细请参见异步并发概述。：允许在同一时间段内同时执行多段代码。
鸿蒙ArkTS实战开发：TaskPool和Worker支持的序列化类型(2)
uiuuyy67的博客
04-11 1028
有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了。
最新鸿蒙HarmonyOS开发文档汇总.zip
08-03
HarmonyOS开发文档（二）； HarmonyOS开发文档（一）； HarmonyOS入门文档； HarmonyOS设备应用开发文档； HarmonyOS应用设计文档； HarmonyOS智慧屏设计文档； HarmonyOS智能穿戴应用设计文档； Huawei DevEco ...
C++多线程编程实战 _C++_线程进程_thread_
10-03
P303.zip
【HarmonyOS NEXT应用开发】案例30：ArkTS多线程的多线程系列（二）：基于Sendable共享对象实现跨线程通信及UI状态刷新
xzs51job的专栏
08-14 57
Step4：当子线程需要更新下载进度条数据，将下载进度设置到DownloadVideoInfo共享对象中，并给主线程发送"UPDATE_DOWNLOAD_PROGRESS"事件，主线程接收到事件后从共享对象中获取下载进度，并刷新UI。4.2 主线程通过onReceiveData接收子线程消息，当判断消息是需要更新下载进度（"UPDATE_DOWNLOAD_PROGRESS"）时，将共享对象中的下载进度赋值给状态变量，更新UI。通过Sendable构建可跨线程共享的对象DownloadVideoInfo；
HarmonyOS 应用开发之TaskPool
1
04-01 1314
任务池（TaskPool）作用是为应用程序提供一个多线程的运行环境，降低整体资源的消耗、提高系统的整体性能，且您无需关心线程实例的生命周期。
详细教程 - 进阶版 鸿蒙harmonyOS应用 第十七节——鸿蒙OS多线程编程指南
爱蹦跶的全栈大A阿
12-22 2532
线程是操作系统调度的最小单元,鸿蒙OS使用轻量级线程实现了良好的并发性能。相比进程间的切换,线程间切换成本更低,可以有效利用多核CPU。但直接使用线程也会增加编程复杂度。本文将详细介绍鸿蒙OS的多线程编程模型、线程间通信与同步机制、并发安全、最佳实践等内容。本文主要介绍了鸿蒙OS的多线程创建与同步互斥机制,解释了线程不安全的根本原因,并给出了设计实现线程安全的各种方式,最后提出了并发优化的最佳实践。多线程并发大大提高了程序执行效率,但也增加了编程难度。
鸿蒙（HarmonyOS）性能优化实战-多线程共享内存
maniuT的博客
04-23 1193
在应用开发中，为了避免主线程阻塞，提高应用性能，需要将一些耗时操作放在子线程中执行。此时，子线程就需要访问主线程中的数据。ArkTS采用了基于消息通信的Actor并发模型，具有内存隔离的特性，所以跨线程传输数据时需要将数据序列化，但是AkrTS支持通过可共享对象SharedArrayBuffer实现直接的共享内存。在开发应用时，如果遇到数据量较大，并且需要多个线程同时操作的情况，推荐使用SharedArrayBuffer共享内存，可以减少数据在线程间传递时需要复制和序列化的额外开销。
自学鸿蒙应用开发（39）- 使用多线程功能实现定时器
面向对象思考
09-16 828
很多应用需要按照一定周期执行某些特定动作，本文通过一个时钟小例子介绍使用使用鸿蒙系统的多线程功能实现这一功能。以下是动作视频： demo 准备布局 下面的代码为了方便实现，使用TimePicker表示现在时间： <?xml version="1.0" encoding="utf-8"?><DirectionalLayout xmlns:ohos="http://schemas.huawei.com/res/ohos" ohos:height="match_p
HarmonyOS教程指南—如何通过ArkTS使用多线程并发-TaskPool
m0_64422261的博客
06-04 1527
任务池（TaskPool）作用是为应用程序提供一个多线程的运行环境，降低整体资源的消耗、提高系统的整体性能，且您无需关心线程实例的生命周期。
HarmonyOS开发学习：定位相关知识（Locationkit）
DMZDAMS的博客
07-08 917
HarmonyOS 应用开发工具DevEco Studio也没有提供读取存储器的功能，所以做一个简单版本的应用级别浏览器还是有必要的。
嵌入式linux/鸿蒙开发板(IMX6ULL）开发（十七）多线程编程
da.的博客
03-13 886
文章目录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.多线程编程 本章将分为两大部分进行讲解，第一部分将引
鸿蒙ArkTS实战开发：多线程并发 (TaskPool和Worker)
shudaoshanQAQ的博客
03-30 2573
并发模型是用来实现不同应用场景中并发任务的编程模型
HarmonyOS网络与多线程实战：异步操作与Http/WebSocket应用
在当今移动互联网时代，HarmonyOS作为华为的智能操作系统，其在网络功能和多线程处理方面的应用变得至关重要。随着人们对手机上便捷服务的需求提升，如购物应用淘宝、美团等，具备网络访问能力的HarmonyOS应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值