鸿蒙OpenHarmony【Worker简介】 ArkTS并发

于 2025-06-19 14:58:39 发布
阅读量1k 收藏 14
点赞数 26
CC 4.0 BY-SA版权
分类专栏： 鸿蒙开发学习 文章标签： harmonyos microsoft 华为 鸿蒙 鸿蒙系统 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhhuuuu_/article/details/148765136

Worker简介

Worker主要作用是为应用程序提供一个多线程的运行环境，可满足应用程序在执行过程中与宿主线程分离，在后台线程中运行一个脚本进行耗时操作，极大避免类似于计算密集型或高延迟的任务阻塞宿主线程的运行。

Worker运作机制

图1 Worker运作机制示意图

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

创建Worker的线程称为宿主线程（不一定是主线程，工作线程也支持创建Worker子线程），Worker自身的线程称为Worker子线程（或Actor线程、工作线程）。每个Worker子线程与宿主线程拥有独立的实例，包含基础设施、对象、代码段等，因此每个Worker启动存在一定的内存开销，需要限制Worker的子线程数量。Worker子线程和宿主线程之间的通信是基于消息传递的，Worker通过序列化机制与宿主线程之间相互通信，完成命令及数据交互。

Worker注意事项

  • 创建Worker时，有手动和自动两种创建方式，手动创建Worker线程目录及文件时，还需同步进行相关配置。
  • 使用Worker能力时，构造函数中传入的Worker线程文件的路径在不同版本有不同的规则。
  • Worker创建后需要手动管理生命周期，且最多同时运行的Worker子线程数量为64个。
  • 由于不同线程中上下文对象是不同的，因此Worker线程只能使用线程安全的库，例如UI相关的非线程安全库不能使用。
  • 序列化传输的数据量大小限制为16MB。
  • 使用Worker模块时，需要在宿主线程中注册onerror接口，否则当Worker线程出现异常时会发生jscrash问题。
  • 不支持跨HAP使用Worker线程文件。
  • 引用HAR/HSP前，需要先配置对HAR/HSP的依赖。
  • 不支持在Worker工作线程中使用[AppStorage]。

创建Worker的注意事项

Worker线程文件需要放在"{moduleName}/src/main/ets/"目录层级之下，否则不会被打包到应用中。有手动和自动两种创建Worker线程目录及文件的方式。

  • 手动创建：开发者手动创建相关目录及文件，此时需要配置build-profile.json5的相关字段信息，Worker线程文件才能确保被打包到应用中。

    Stage模型：

    "buildOption": {
  "sourceOption": {
    "workers": [
      "./src/main/ets/workers/worker.ets"
    ]
  }
}

    FA模型：

    "buildOption": {
  "sourceOption": {
    "workers": [
      "./src/main/ets/MainAbility/workers/worker.ets"
    ]
  }
}

  • 自动创建：DevEco Studio支持一键生成Worker，在对应的{moduleName}目录下任意位置，点击鼠标右键 > New > Worker，即可自动生成Worker的模板文件及配置信息，无需再手动在build-profile.json5中进行相关配置。

文件路径注意事项

当使用Worker模块具体功能时，均需先构造Worker实例对象，其构造函数与API版本相关，且构造函数需要传入Worker线程文件的路径（scriptURL）。

// 导入模块
import { worker } from '@kit.ArkTS';

// API 9及之后版本使用：
const worker1: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/worker.ets');
// API 8及之前版本使用：
const worker2: worker.Worker = new worker.Worker('entry/ets/workers/worker.ets');
Stage模型下的文件路径规则

构造函数中的scriptURL要求如下：

  • scriptURL的组成包含 {moduleName}/ets 和相对路径 relativePath。
  • relativePath是Worker线程文件相对于"{moduleName}/src/main/ets/"目录的相对路径。

1） 加载Ability中Worker线程文件场景

加载Ability中的worker线程文件，加载路径规则：{moduleName}/ets/{relativePath}。

import { worker } from '@kit.ArkTS';

// worker线程文件所在路径："entry/src/main/ets/workers/worker.ets"
const workerStage1: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/worker.ets');

// worker线程文件所在路径："phone/src/main/ets/ThreadFile/workers/worker.ets"
const workerStage2: worker.ThreadWorker = new worker.ThreadWorker('phone/ets/ThreadFile/workers/worker.ets');

2） 加载[HSP]中Worker线程文件场景

加载HSP中worker线程文件，加载路径规则：{moduleName}/ets/{relativePath}。

import { worker } from '@kit.ArkTS';

// worker线程文件所在路径： "hsp/src/main/ets/workers/worker.ets"
const workerStage3: worker.ThreadWorker = new worker.ThreadWorker('hsp/ets/workers/worker.ets');

3） 加载[HAR]中Worker线程文件场景

加载HAR中worker线程文件存在以下两种情况：

  • @标识路径加载形式：所有种类的模块加载本地HAR中的Worker线程文件，加载路径规则：@{moduleName}/ets/{relativePath}。
  • 相对路径加载形式：本地HAR加载该包内的Worker线程文件，加载路径规则：创建Worker对象所在文件与Worker线程文件的相对路径。

说明：

当开启useNormalizedOHMUrl（即将工程目录中与entry同级别的应用级build-profile.json5文件中strictMode属性的useNormalizedOHMUrl字段配置为true）或HAR包会被打包成三方包使用时，则HAR包中使用Worker仅支持通过相对路径的加载形式创建。

import { worker } from '@kit.ArkTS';

// @标识路径加载形式：
// worker线程文件所在路径: "har/src/main/ets/workers/worker.ets"
const workerStage4: worker.ThreadWorker = new worker.ThreadWorker('@har/ets/workers/worker.ets');

// 相对路径加载形式：
// worker线程文件所在路径: "har/src/main/ets/workers/worker.ets"
// 创建Worker对象的文件所在路径："har/src/main/ets/components/mainpage/MainPage.ets"
const workerStage5: worker.ThreadWorker = new worker.ThreadWorker('../../workers/worker.ets');
FA模型下的文件路径规则

构造函数中的scriptURL为：Worker线程文件与"{moduleName}/src/main/ets/MainAbility"的相对路径。

import { worker } from '@kit.ArkTS';

// 主要说明以下三种场景：

// 场景1： Worker线程文件所在路径："{moduleName}/src/main/ets/MainAbility/workers/worker.ets"
const workerFA1: worker.ThreadWorker = new worker.ThreadWorker("workers/worker.ets", {name:"first worker in FA model"});

// 场景2： Worker线程文件所在路径："{moduleName}/src/main/ets/workers/worker.ets"
const workerFA2: worker.ThreadWorker = new worker.ThreadWorker("../workers/worker.ets");

// 场景3： Worker线程文件所在路径："{moduleName}/src/main/ets/MainAbility/ThreadFile/workers/worker.ets"
const workerFA3: worker.ThreadWorker = new worker.ThreadWorker("ThreadFile/workers/worker.ets");

生命周期注意事项

  • Worker的创建和销毁耗费性能，建议开发者合理管理已创建的Worker并重复使用。Worker空闲时也会一直运行，因此当不需要Worker时，可以调用[terminate()]接口或[close()]方法主动销毁Worker。若Worker处于已销毁或正在销毁等非运行状态时，调用其功能接口，会抛出相应的错误。
  • Worker的数量由内存管理策略决定，设定的内存阈值为1.5GB和设备物理内存的60%中的较小者。在内存允许的情况下，系统最多可以同时运行64个Worker。如果尝试创建的Worker数量超出这一上限，系统将抛出错误：“Worker initialization failure, the number of workers exceeds the maximum.”。实际运行的Worker数量会根据当前内存使用情况动态调整。一旦所有Worker和主线程的累积内存占用超过了设定的阈值，系统将触发内存溢出（OOM）错误，导致应用程序崩溃。

跨har包加载Worker

  1. 创建har详情参考[开发静态共享包]。

  2. 在har中创建Worker线程文件相关内容。

    // worker.ets
workerPort.onmessage = (e: MessageEvents) => {
  console.info("worker thread receive message: ", e.data);
  workerPort.postMessage('worker thread post message to main thread');
}

  3. 在entry模块的oh-package.json5文件中配置har包的依赖。

    // 在entry模块配置har包的依赖
{
  "name": "entry",
  "version": "1.0.0",
  "description": "Please describe the basic information.",
  "main": "",
  "author": "",
  "license": "",
  "dependencies": {
    "har": "file:../har"
  }
}

  4. 在entry模块中加载har包中的Worker线程文件。

    // Index.ets
import { worker } from '@kit.ArkTS';

@Entry
@Component
struct Index {
  @State message: string = 'Hello World';

  build() {
    RelativeContainer() {
      Text(this.message)
        .id('HelloWorld')
        .fontSize(50)
        .fontWeight(FontWeight.Bold)
        .alignRules({
          center: { anchor: '__container__', align: VerticalAlign.Center },
          middle: { anchor: '__container__', align: HorizontalAlign.Center }
        })
        .onClick(() => {
          // 通过@标识路径加载形式，加载har中Worker线程文件
          let workerInstance = new worker.ThreadWorker('@har/ets/workers/worker.ets');
          workerInstance.onmessage = () => {
            console.info('main thread onmessage');
          };
          workerInstance.postMessage('hello world');
        })
    }
    .height('100%')
    .width('100%')
  }
}

多级Worker生命周期管理

由于支持创建多级Worker（即通过父Worker创建子Worker的机制形成层级线程关系），且Worker线程生命周期由用户自行管理，因此需要注意多级Worker生命周期的正确管理。若用户销毁父Worker时未能结束其子Worker的运行，会产生不可预期的结果。建议用户确保子Worker的生命周期始终在父Worker生命周期范围内，并在销毁父Worker前先销毁所有子Worker。

推荐使用示例

// 在主线程中创建Worker线程（父Worker），在worker线程中再次创建Worker线程（子Worker）
// main thread
import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS';

// 主线程中创建父worker对象
const parentworker = new worker.ThreadWorker("entry/ets/workers/parentworker.ets");

parentworker.onmessage = (e: MessageEvents) => {
  console.info("主线程收到父worker线程信息 " + e.data);
}

parentworker.onexit = () => {
  console.info("父worker退出");
}

parentworker.onerror = (err: ErrorEvent) => {
  console.info("主线程接收到父worker报错 " + err);
}

parentworker.postMessage("主线程发送消息给父worker-推荐示例");

// parentworker.ets
import { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';

// 创建父Worker线程中与主线程通信的对象
const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (e : MessageEvents) => {
  if (e.data == "主线程发送消息给父worker-推荐示例") {
    let childworker = new worker.ThreadWorker("entry/ets/workers/childworker.ets");

    childworker.onmessage = (e: MessageEvents) => {
      console.info("父Worker收到子Worker的信息 " + e.data);
      if (e.data == "子Worker向父Worker发送信息") {
        workerPort.postMessage("父Worker向主线程发送信息");
      }
    }

    childworker.onexit = () => {
      console.info("子Worker退出");
      // 子Worker退出后再销毁父Worker
      workerPort.close();
    }

    childworker.onerror = (err: ErrorEvent) => {
      console.info("子Worker发生报错 " + err);
    }

    childworker.postMessage("父Worker向子Worker发送信息-推荐示例");
  }
}

// childworker.ets
import { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';

// 创建子Worker线程中与父Worker线程通信的对象
const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (e: MessageEvents) => {
  if (e.data == "父Worker向子Worker发送信息-推荐示例") {
    // 子Worker线程业务逻辑...
    console.info("业务执行结束，然后子Worker销毁");
    workerPort.close();
  }
}

不推荐使用示例

不建议父Worker主动销毁后，子Worker仍向父Worker发送消息。

// main thread
import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS';

const parentworker = new worker.ThreadWorker("entry/ets/workers/parentworker.ets");

parentworker.onmessage = (e: MessageEvents) => {
  console.info("主线程收到父Worker信息" + e.data);
}

parentworker.onexit = () => {
  console.info("父Worker退出");
}

parentworker.onerror = (err: ErrorEvent) => {
  console.info("主线程接收到父Worker报错 " + err);
}

parentworker.postMessage("主线程发送消息给父Worker");

// parentworker.ets
import { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (e : MessageEvents) => {
  console.info("父Worker收到主线程的信息 " + e.data);

  let childworker = new worker.ThreadWorker("entry/ets/workers/childworker.ets")

  childworker.onmessage = (e: MessageEvents) => {
    console.info("父Worker收到子Worker的信息 " + e.data);
  }

  childworker.onexit = () => {
    console.info("子Worker退出");
    workerPort.postMessage("父Worker向主线程发送信息");
  }

  childworker.onerror = (err: ErrorEvent) => {
    console.info("子Worker发生报错 " + err);
  }

  childworker.postMessage("父Worker向子Worker发送信息");

  // 创建子Worker后，销毁父Worker
  workerPort.close();
}

// childworker.ets
import { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (e: MessageEvents) => {
  console.info("子Worker收到信息 " + e.data);

  // 父Worker销毁后，子Worker向父Worker发送信息，行为不可预期
  workerPort.postMessage("子Worker向父Worker发送信息");
  setTimeout(() => {
    workerPort.postMessage("子Worker向父Worker发送信息");
  }, 1000);
}

不建议在明确父Worker发起销毁操作的同步调用前后仍在父Worker线程创建子Worker。不建议在不确定父Worker是否发起销毁操作的情况下，仍在父Worker线程创建子Worker，即创建子Worker线程成功之前需保证父Worker线程始终处于存活状态。

// main thread
import { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS';

const parentworker = new worker.ThreadWorker("entry/ets/workers/parentworker.ets");

parentworker.onmessage = (e: MessageEvents) => {
  console.info("主线程收到父Worker信息" + e.data);
}

parentworker.onexit = () => {
  console.info("父Worker退出");
}

parentworker.onerror = (err: ErrorEvent) => {
  console.info("主线程接收到父Worker报错 " + err);
}

parentworker.postMessage("主线程发送消息给父Worker");

// parentworker.ets
import { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (e : MessageEvents) => {
  console.info("父Worker收到主线程的信息 " + e.data);

  // 父Worker销毁后创建子Worker，行为不可预期
  workerPort.close();
  let childworker = new worker.ThreadWorker("entry/ets/workers/childworker.ets");

  // 子Worker线程未确认创建成功前销毁父Worker，行为不可预期
  // let childworker = new worker.ThreadWorker("entry/ets/workers/childworker.ets");
  // workerPort.close();

  childworker.onmessage = (e: MessageEvents) => {
    console.info("父Worker收到子Worker的信息 " + e.data);
  }

  childworker.onexit = () => {
    console.info("子Worker退出");
    workerPort.postMessage("父Worker向主线程发送信息");
  }

  childworker.onerror = (err: ErrorEvent) => {
    console.info("子Worker发生报错 " + err);
  }

  childworker.postMessage("父Worker向子Worker发送信息");
}

// childworker.ets
import { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';

const workerPort: ThreadWorkerGlobalScope = worker.workerPort;

workerPort.onmessage = (e: MessageEvents) => {
  console.info("子Worker收到信息 " + e.data);
}
【鸿蒙实战开发】基于Taskpool的多线程操作
HarmonyOSMN的博客
06-28 1113
周期性任务处理，业务通过taskpool周期性处理业务。：延迟业务处理，业务一段时间后，通过taskpool处理业务。：串行业务处理，业务开展过程中，需要处理一系列的事务，事务处理过程中，存在先后次序。：业务的处理存在紧急优先次序，支持设置taskpool优先级处理。：ArkTS与Native协作开展业务，在ArkTS层触发业务，通过NAPI接口，传递到Native C++层，作业务管理等处理。方案：1)定时器判断周期性事务执行。2)Taskpool来处理任务执行。
【HarmonyOS NEXT】鸿蒙多线程Sendable开发
wu1004019946的博客
07-02 3471
由于Sendable对象在不同并发实例间的上下文环境不同，如果直接访问会有非预期行为。不支持Sendable对象使用当前模块内上下文环境中定义的变量，如果违反，编译阶段会报错。从API version 12开始，sendable class的内部支持使用top level的sendable class对象。
鸿蒙开发0基础【Worker简介】ArkTS并发
zhenggaoxiao232的博客
04-10 624
Worker主要作用是为应用程序提供一个多线程的运行环境，可满足应用程序在执行过程中与宿主线程分离，在后台线程中运行一个脚本进行耗时操作，极大避免类似于计算密集型或高延迟的任务阻塞宿主线程的运行。
OpenHarmony实战开发-合理使用多线程共享内存。
m0_70749039的博客
04-22 1099
在应用开发中，为了避免主线程阻塞，提高应用性能，需要将一些耗时操作放在子线程中执行。此时，子线程就需要访问主线程中的数据。ArkTS采用了基于消息通信的Actor并发模型，具有内存隔离的特性，所以跨线程传输数据时需要将数据序列化，但是AkrTS支持通过可共享对象SharedArrayBuffer实现直接的共享内存。
【HarmonyOS NEXT】鸿蒙多线程共享模块开发
wu1004019946的博客
07-02 668
共享模块是进程内只会加载一次的模块，使用"use shared"这一指令来标记一个模块是否为共享模块。非共享模块在同一线程内只加载一次，在不同线程间会加载多次，在不同的线程内都会产生新的模块对象。
鸿蒙OpenHarmony【Worker和宿主线程的即时消息通信】 ArkTS并发线程间通信
adsjgfjha123123的博客
12-09 613
在ArkTS中，Worker相对于Taskpool存在一定的差异性，有数量限制但是可以长时间存在。一个[Worker]中可能会执行多个不同的任务，每个任务执行的时长或者返回的结果可能都不相同，宿主线程需要根据情况调用Worker中的不同方法，Worker则需要及时地将结果返回给宿主线程。
鸿蒙OpenHarmony【异步并发 (Promise和async/await)】 ArkTS并发
adsjgfjha123123的博客
12-06 606
并发是指在同一时间内，存在多个任务同时执行的情况。对于多核设备，这些任务可能同时在不同CPU上并行执行。对于单核设备，多个并发任务不会在同一时刻并行执行，但是CPU会在某个任务休眠或进行I/O操作等状态下切换任务，调度执行其他任务，提升CPU的资源利用率。
鸿蒙OpenHarmony【同步任务开发】 ArkTS并发线程间通信
adsjgfjha123123的博客
12-10 702
同步任务是指在多个线程之间协调执行的任务，其目的是确保多个任务按照一定的顺序和规则执行，例如使用锁来防止数据竞争。 同步任务的实现需要考虑多个线程之间的协作和同步，以确保数据的正确性和程序的正确执行。 由于TaskPool偏向于单个独立的任务，因此当各个同步任务之间相对独立时推荐使用TaskPool，例如一系列导入的静态方法，或者单例实现的方法。如果同步任务之间有关联性，则需要使用Worker，例如无法单例创建的类对象实现的方法。
鸿蒙ArkTS实战开发：多线程并发-Worker
m0_70749039的博客
06-04 1717
Worker主要作用是为应用程序提供一个多线程的运行环境，可满足应用程序在执行过程中与主线程分离，在后台线程中运行一个脚本操作耗时操作，极大避免类似于计算密集型或高延迟的任务阻塞主线程的运行。
鸿蒙OpenHarmony【CPU密集型任务开发】 ArkTS并发线程间通信
adsjgfjha123123的博客
12-09 291
ArkTS应用开发过程中，需要用到并发能力的业务场景很多，不同业务场景需要使用的并发能力不同，对应的主要任务类型也不同。 针对常见的业务场景，主要可以对应分为三种并发任务：[耗时任务]、[长时任务]、[常驻任务]。
嵌入式linux/鸿蒙开发板(IMX6ULL）开发（十七）多线程编程
da.的博客
03-13 1067
文章目录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.多线程编程 本章将分为两大部分进行讲解，第一部分将引
鸿蒙（HarmonyOS）性能优化实战-多线程共享内存
maniuT的博客
04-23 1452
在应用开发中，为了避免主线程阻塞，提高应用性能，需要将一些耗时操作放在子线程中执行。此时，子线程就需要访问主线程中的数据。ArkTS采用了基于消息通信的Actor并发模型，具有内存隔离的特性，所以跨线程传输数据时需要将数据序列化，但是AkrTS支持通过可共享对象SharedArrayBuffer实现直接的共享内存。在开发应用时，如果遇到数据量较大，并且需要多个线程同时操作的情况，推荐使用SharedArrayBuffer共享内存，可以减少数据在线程间传递时需要复制和序列化的额外开销。
鸿蒙「TaskPool|Worker」多线程并发使用详解，这一篇足够！
文化园
08-15 3771
CPU密集型任务，说白了是计算型耗时任务； I/O密集型任务，说白了是读写型耗时任务； 官方文档重点介绍了这两种基于多线程并发机制处理任务类型，我们是要深度思考下的？！「很有意义」，是否已经包含且指明了我们使用「TaskPool/Worker」来解决项目问题的方案呢？ 对Worker以及TaskPool的使用详解，个人准备以一种特别的角度来详述。从我个人初始接触及学习研究的视角，针对 `如何选用`、`如何创建`、`如何使用`、`注意事项`和`条件限制` 多个方面，全面剖析。
HarmonyNext技术深度解析：ArkTS在鸿蒙系统中的多线程与并发编程实践
2301_80441238的博客
03-02 994
本指南深入解析HarmonyNext在安全架构与系统级性能优化方面的技术实现，通过典型场景的代码示例演示了从底层硬件接口调用到上层应用安全开发的完整流程。开发者可结合具体业务需求，灵活运用文中提供的安全存储方案、性能优化策略及调试方法，构建符合HarmonyNext设计哲学的高质量应用。this.sessionKey) throw new Error(‘会话未初始化’);硬件级信任根：基于Secure Boot 2.0标准，实现启动镜像的数字签名验证。Button(‘指纹+人脸融合认证’)
【Day 8】鸿蒙中多线程的开发
最新发布
梦想不只是梦与想的博客
04-25 1882
鸿蒙中多线程的开发
鸿蒙开发基础 —— 多线程并发(Worker)
guangxishaoji的博客
02-25 938
创建Worker的线程称为宿主线程（不一定是主线程，工作线程也支持创建Worker子线程），Worker自身的线程称为Worker子线程（或Actor线程、工作线程）。每个Worker子线程与宿主线程拥有独立的实例，包含基础设施、对象、代码段等，因此每个Worker启动存在一定的内存开销，需要限制Worker的子线程数量。当使用Worker模块具体功能时，均需先构造Worker实例对象，其构造函数与API版本相关，且构造函数需要传入Worker线程文件的路径（scriptURL）。
OpenHarmony实战开发-如何启动worker线程和taskpool线程。
2401_82546228的博客
04-14 928
本示例通过@ohos.taskpool 和@ohos.worker 接口，展示了如何启动worker线程和taskpool线程。
【鸿蒙开发】第十五章 ArkTS基础类库-并发
Yvan
03-03 2525
为了提升应用的响应速度与帧率，以及防止耗时任务对主线程的干扰，系统提供了异步并发和多线程并发两种处理策略，ArkTS支持异步并发和多线程并发。并发能力在多种场景中都有应用，其中包括单次I/O任务CPU密集型任务I/O密集型任务和同步任务等。：是指异步代码在执行到一定程度后会被暂停，以便在未来某个时间点继续执行，这种情况下，同一时间只有一段代码在执行。Promise和提供异步并发能力，适用于单次I/O任务的开发场景。详细请参见异步并发概述。：允许在同一时间段内同时执行多段代码。
自学鸿蒙应用开发（39）- 使用多线程功能实现定时器
面向对象思考
09-16 894
很多应用需要按照一定周期执行某些特定动作，本文通过一个时钟小例子介绍使用使用鸿蒙系统的多线程功能实现这一功能。以下是动作视频： demo 准备布局 下面的代码为了方便实现，使用TimePicker表示现在时间： <?xml version="1.0" encoding="utf-8"?><DirectionalLayout xmlns:ohos="http://schemas.huawei.com/res/ohos" ohos:height="match_p
鸿蒙开发Worker线程改写UI
01-01
### 鸿蒙 OS Worker 线程更新 UI 的方法 在鸿蒙操作系统中，Worker 是一种用于执行长时间运行的任务而不阻塞主线程的机制。由于 Worker 运行在一个独立的工作线程上，因此它无法直接访问或修改 UI 组件。为了实现从 Worker 线程向 UI 发送消息并更新界面的效果，通常采用以下几种方式： #### 使用 Emitter 实现线程间通信 Emitter 提供了一种发布/订阅模式的消息传递机制，允许不同线程之间发送和接收消息。可以在 Worker 中触发事件，在主线程监听这些事件来间接达到更新 UI 的目的。 ```typescript // 主线程代码片段 import emitter from '@ohos.event.emitter'; emitter.on('updateUI', (data) => { console.info(`Received data: ${JSON.stringify(data)}`); // 执行具体的UI更新逻辑 }); // Worker线程中的代码片段 export default function MyWorker() { let worker = new Worker(); worker.postMessage({ action: 'doSomething', payload: {} }); worker.onmessage = (event) => { const resultData = event.data; // 向主线程发出信号以请求刷新UI emitter.emit('updateUI', { message: "Update your UI here", ...resultData }); }; } ``` 此段代码展示了如何利用 `@ohos.event.emitter` 模块完成跨线程的数据交换[^1]。 #### 利用 AbilitySlice 上下文对象的方法调用 如果是在特定的应用场景比如Ability环境下工作，则可以直接借助AbilitySlice提供的接口来进行UI交互。例如，可以通过 abilityContext.runOnUIThread 来安排任务在UI线程上同步执行。 ```javascript abilityContext.runOnUiThread(() -> { // 在这里放置需要在线程中立即执行的操作 }); ``` 需要注意的是这种方法仅适用于某些特殊情况下，并不是通用解决方案[^3]。 #### 注意事项 - 创建过多的 Workers 可能会引起性能问题以及资源浪费；自 API 版本 9 起，当超过最大允许数目的时候将会引发初始化失败异常而不是简单的拒绝创建新的实例[^4]。 - 尽量减少不必要的线程切换次数，因为频繁地在这两者之间转换可能会带来额外开销影响程序效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值